diff --git a/lib/bitcoin_flutter.dart b/lib/bitcoin_flutter.dart
index a77de46..55987b1 100644
--- a/lib/bitcoin_flutter.dart
+++ b/lib/bitcoin_flutter.dart
@@ -9,7 +9,32 @@ export 'src/transaction.dart';
 export 'src/address.dart';
 export 'src/transaction_builder.dart';
 export 'src/ecpair.dart';
-export 'src/payments/p2pkh.dart';
+export 'src/ec/ec_public.dart';
+export 'src/ec/ec_encryption.dart';
 export 'src/payments/p2wpkh.dart';
 export 'src/payments/index.dart';
+export 'src/payments/scanning.dart';
+export 'src/payments/address/core.dart';
+export 'src/payments/address/address.dart' show P2shAddress, P2pkhAddress;
+export 'src/payments/address/segwit_address.dart' show P2wpkhAddress, P2trAddress;
+export 'src/payments/script/script.dart';
+export 'src/templates/silentpaymentaddress.dart';
+export 'src/templates/outpoint.dart';
+export 'src/payments/silentpayments.dart';
+export 'src/utils/keys.dart';
+export 'src/utils/uint8list.dart';
+export 'src/utils/string.dart';
+export 'src/formatting/bytes_num_formatting.dart';
+export 'src/classify.dart';
+
+export 'src/payments/bitcoin/input.dart';
+export 'src/payments/bitcoin/output.dart';
+export 'src/payments/bitcoin/witness.dart';
+export 'src/payments/bitcoin/transaction_builder.dart';
+export 'src/payments/bitcoin/transaction.dart';
+export 'src/payments/bitcoin/utxo_details.dart';
+export 'src/payments/bitcoin/multisig_script.dart';
+
+export 'package:bech32/bech32.dart';
+export 'package:elliptic/elliptic.dart';
 // TODO: Export any libraries intended for clients of this package.
diff --git a/lib/src/address.dart b/lib/src/address.dart
index 3fa7902..fa3ea52 100644
--- a/lib/src/address.dart
+++ b/lib/src/address.dart
@@ -1,10 +1,8 @@
 import 'dart:typed_data';
-import 'models/networks.dart';
-import 'package:bs58check/bs58check.dart' as bs58check;
-import 'package:bech32/bech32.dart';
-import 'payments/index.dart' show PaymentData;
-import 'payments/p2pkh.dart';
-import 'payments/p2wpkh.dart';
+
+import 'package:bitcoin_flutter/src/models/networks.dart';
+import 'package:bitcoin_flutter/src/payments/address/address.dart';
+import 'package:bitcoin_flutter/src/payments/address/segwit_address.dart';
 
 class Address {
   static bool validateAddress(String address, [NetworkType? nw]) {
@@ -18,31 +16,23 @@ class Address {
 
   static Uint8List addressToOutputScript(String address, [NetworkType? nw]) {
     NetworkType network = nw ?? bitcoin;
-    var decodeBase58;
-    var decodeBech32;
-    try {
-      decodeBase58 = bs58check.decode(address);
-    } catch (err) {}
-    if (decodeBase58 != null) {
-      if (decodeBase58[0] != network.pubKeyHash)
-        throw new ArgumentError('Invalid version or Network mismatch');
-      P2PKH p2pkh =
-          new P2PKH(data: new PaymentData(address: address), network: network);
-      return p2pkh.data.output!;
-    } else {
-      try {
-        decodeBech32 = segwit.decode(address);
-      } catch (err) {}
-      if (decodeBech32 != null) {
-        if (network.bech32 != decodeBech32.hrp)
-          throw new ArgumentError('Invalid prefix or Network mismatch');
-        if (decodeBech32.version != 0)
-          throw new ArgumentError('Invalid address version');
-        P2WPKH p2wpkh = new P2WPKH(
-            data: new PaymentData(address: address), network: network);
-        return p2wpkh.data.output!;
-      }
+
+    if (P2pkhAddress.REGEX.hasMatch(address)) {
+      return P2pkhAddress(address: address, networkType: network).scriptPubkey.toBytes();
+    }
+
+    if (P2shAddress.REGEX.hasMatch(address)) {
+      return P2shAddress(address: address, networkType: network).scriptPubkey.toBytes();
     }
+
+    if (P2wpkhAddress.REGEX.hasMatch(address)) {
+      return P2wpkhAddress(address: address, networkType: network).scriptPubkey.toBytes();
+    }
+
+    if (P2trAddress.REGEX.hasMatch(address)) {
+      return P2trAddress(address: address, networkType: network).scriptPubkey.toBytes();
+    }
+
     throw new ArgumentError(address + ' has no matching Script');
   }
 }
diff --git a/lib/src/bitcoin_flutter_base.dart b/lib/src/bitcoin_flutter_base.dart
index b310340..cbdd750 100644
--- a/lib/src/bitcoin_flutter_base.dart
+++ b/lib/src/bitcoin_flutter_base.dart
@@ -2,19 +2,17 @@
 import 'dart:typed_data';
 import 'package:bitcoin_flutter/src/utils/magic_hash.dart';
 import 'package:bitcoin_flutter/src/utils/recoverable_signatures.dart';
+import 'package:bitcoin_flutter/src/utils/uint8list.dart';
+import 'package:bitcoin_flutter/src/payments/address/address.dart';
 import 'package:hex/hex.dart';
 import 'package:bip32/bip32.dart' as bip32;
-import 'models/networks.dart';
-import 'payments/index.dart' show PaymentData;
-import 'payments/p2pkh.dart';
+import 'package:bitcoin_flutter/src/models/networks.dart';
 import 'ecpair.dart';
-import 'package:meta/meta.dart';
-import 'dart:convert';
 
 /// Checks if you are awesome. Spoiler: you are.
 class HDWallet {
   bip32.BIP32? _bip32;
-  P2PKH? _p2pkh;
+  P2pkhAddress? _p2pkh;
   String? seed;
   NetworkType network;
 
@@ -52,25 +50,22 @@ class HDWallet {
     }
   }
 
-  String? get address => _p2pkh != null ? _p2pkh?.data.address : null;
+  String? get address => _p2pkh != null ? _p2pkh?.address : null;
 
-  HDWallet(
-      {bip32.BIP32? bip32, P2PKH? p2pkh, required this.network, this.seed}) {
+  HDWallet({bip32.BIP32? bip32, P2pkhAddress? p2pkh, required this.network, this.seed}) {
     this._bip32 = bip32;
     this._p2pkh = p2pkh;
   }
 
   HDWallet derivePath(String path) {
     final bip32 = _bip32!.derivePath(path);
-    final p2pkh = new P2PKH(
-        data: new PaymentData(pubkey: bip32.publicKey), network: network);
+    final p2pkh = new P2pkhAddress(pubkey: bip32.publicKey.hex, networkType: network);
     return HDWallet(bip32: bip32, p2pkh: p2pkh, network: network);
   }
 
   HDWallet derive(int index) {
     final bip32 = _bip32!.derive(index);
-    final p2pkh = new P2PKH(
-        data: new PaymentData(pubkey: bip32.publicKey), network: network);
+    final p2pkh = new P2pkhAddress(pubkey: bip32.publicKey.hex, networkType: network);
     return HDWallet(bip32: bip32, p2pkh: p2pkh, network: network);
   }
 
@@ -80,13 +75,10 @@ class HDWallet {
     final wallet = bip32.BIP32.fromSeed(
         seed,
         bip32.NetworkType(
-            bip32: bip32.Bip32Type(
-                public: network.bip32.public, private: network.bip32.private),
+            bip32: bip32.Bip32Type(public: network.bip32.public, private: network.bip32.private),
             wif: network.wif));
-    final p2pkh = new P2PKH(
-        data: new PaymentData(pubkey: wallet.publicKey), network: network);
-    return HDWallet(
-        bip32: wallet, p2pkh: p2pkh, network: network, seed: seedHex);
+    final p2pkh = new P2pkhAddress(pubkey: wallet.publicKey.hex, networkType: network);
+    return HDWallet(bip32: wallet, p2pkh: p2pkh, network: network, seed: seedHex);
   }
 
   factory HDWallet.fromBase58(String xpub, {NetworkType? network}) {
@@ -94,11 +86,9 @@ class HDWallet {
     final wallet = bip32.BIP32.fromBase58(
         xpub,
         bip32.NetworkType(
-            bip32: bip32.Bip32Type(
-                public: network.bip32.public, private: network.bip32.private),
+            bip32: bip32.Bip32Type(public: network.bip32.public, private: network.bip32.private),
             wif: network.wif));
-    final p2pkh = new P2PKH(
-        data: new PaymentData(pubkey: wallet.publicKey), network: network);
+    final p2pkh = new P2pkhAddress(pubkey: wallet.publicKey.hex, networkType: network);
     return HDWallet(bip32: wallet, p2pkh: p2pkh, network: network, seed: null);
   }
 
@@ -116,10 +106,8 @@ class HDWallet {
     final messageHash = magicHash(message, network);
     final rs = _bip32!.sign(messageHash) as Uint8List;
     final rawSig = rs.toECSignature();
-    final recId = findRecoveryId(
-        getHexString(messageHash, offset: 0, length: messageHash.length),
-        rawSig,
-        _bip32!.publicKey);
+    final recId = findRecoveryId(getHexString(messageHash, offset: 0, length: messageHash.length),
+        rawSig, _bip32!.publicKey);
 
     final v = recId + 27 + (_bip32!.publicKey.isCompressedPoint() ? 4 : 0);
 
@@ -129,16 +117,15 @@ class HDWallet {
 
 class Wallet {
   ECPair? _keyPair;
-  P2PKH? _p2pkh;
+  P2pkhAddress? _p2pkh;
 
-  String? get privKey =>
-      _keyPair != null ? HEX.encode(_keyPair!.privateKey!) : null;
+  String? get privKey => _keyPair != null ? HEX.encode(_keyPair!.privateKey!) : null;
 
   String? get pubKey => _keyPair != null ? HEX.encode(_keyPair!.publicKey) : null;
 
   String? get wif => _keyPair != null ? _keyPair!.toWIF() : null;
 
-  String? get address => _p2pkh != null ? _p2pkh!.data.address : null;
+  String? get address => _p2pkh != null ? _p2pkh!.address : null;
 
   NetworkType network;
 
@@ -146,16 +133,14 @@ class Wallet {
 
   factory Wallet.random(NetworkType network) {
     final _keyPair = ECPair.makeRandom(network: network);
-    final _p2pkh = new P2PKH(
-        data: new PaymentData(pubkey: _keyPair.publicKey), network: network);
+    final _p2pkh = new P2pkhAddress(pubkey: _keyPair.publicKey.hex, networkType: network);
     return Wallet(_keyPair, _p2pkh, network);
   }
 
   factory Wallet.fromWIF(String wif, [NetworkType? network]) {
     network = network ?? bitcoin;
     final _keyPair = ECPair.fromWIF(wif, network: network);
-    final _p2pkh = new P2PKH(
-        data: new PaymentData(pubkey: _keyPair.publicKey), network: network);
+    final _p2pkh = new P2pkhAddress(pubkey: _keyPair.publicKey.hex, networkType: network);
     return Wallet(_keyPair, _p2pkh, network);
   }
 
@@ -169,15 +154,12 @@ class Wallet {
     return _keyPair!.verify(messageHash, signature);
   }
 
-
   Uint8List signMessage(String message) {
     final messageHash = magicHash(message, network);
     final rs = _keyPair!.sign(messageHash);
     final rawSig = rs.toECSignature();
-    final recId = findRecoveryId(
-        getHexString(messageHash, offset: 0, length: messageHash.length),
-        rawSig,
-        _keyPair!.publicKey);
+    final recId = findRecoveryId(getHexString(messageHash, offset: 0, length: messageHash.length),
+        rawSig, _keyPair!.publicKey);
 
     final v = recId + 27 + (_keyPair!.publicKey.isCompressedPoint() ? 4 : 0);
 
diff --git a/lib/src/classify.dart b/lib/src/classify.dart
index 6e986fd..390bea9 100644
--- a/lib/src/classify.dart
+++ b/lib/src/classify.dart
@@ -1,6 +1,6 @@
 import 'dart:typed_data';
 import '../src/utils/script.dart' as bscript;
-import 'templates/pubkeyhash.dart' as pubkeyhash;
+import '../src/payments/address/address.dart';
 import 'templates/pubkey.dart' as pubkey;
 import 'templates/witnesspubkeyhash.dart' as witnessPubKeyHash;
 
@@ -12,13 +12,15 @@ const SCRIPT_TYPES = {
   'P2PKH': 'pubkeyhash',
   'P2SH': 'scripthash',
   'P2WPKH': 'witnesspubkeyhash',
+  'P2TR': 'taproot',
   'P2WSH': 'witnessscripthash',
   'WITNESS_COMMITMENT': 'witnesscommitment'
 };
 
 String classifyOutput(Uint8List script) {
   if (witnessPubKeyHash.outputCheck(script)) return SCRIPT_TYPES['P2WPKH']!;
-  if (pubkeyhash.outputCheck(script)) return SCRIPT_TYPES['P2PKH']!;
+  if (witnessPubKeyHash.taprootOutputCheck(script)) return SCRIPT_TYPES['P2TR']!;
+  if (P2pkhAddress.validPubkeyScript(script)) return SCRIPT_TYPES['P2PKH']!;
   final chunks = bscript.decompile(script);
   if (chunks == null) throw new ArgumentError('Invalid script');
   return SCRIPT_TYPES['NONSTANDARD']!;
@@ -27,7 +29,9 @@ String classifyOutput(Uint8List script) {
 String classifyInput(Uint8List script) {
   final chunks = bscript.decompile(script);
   if (chunks == null) throw new ArgumentError('Invalid script');
-  if (pubkeyhash.inputCheck(chunks)) return SCRIPT_TYPES['P2PKH']!;
+  try {
+    if (P2pkhAddress.validSigScript(script)) return SCRIPT_TYPES['P2PKH']!;
+  } catch (e) {}
   if (pubkey.inputCheck(chunks)) return SCRIPT_TYPES['P2PK']!;
   return SCRIPT_TYPES['NONSTANDARD']!;
 }
diff --git a/lib/src/crypto.dart b/lib/src/crypto.dart
index c6bd7eb..8459ed1 100644
--- a/lib/src/crypto.dart
+++ b/lib/src/crypto.dart
@@ -19,3 +19,45 @@ Uint8List hash256(Uint8List buffer) {
   Uint8List _tmp = new SHA256Digest().process(buffer);
   return new SHA256Digest().process(_tmp);
 }
+
+/// Function: doubleHash
+/// Description: Computes a double SHA-256 hash of the input data.
+/// Input: Uint8List buffer - The data to be hashed.
+/// Output: Uint8List - The resulting double SHA-256 hash.
+/// Note: Double hashing is a common cryptographic technique used to enhance data security.
+Uint8List doubleHash(Uint8List buffer) {
+  /// Compute the first SHA-256 hash of the input data.
+  Uint8List tmp = SHA256Digest().process(buffer);
+
+  /// Compute the second SHA-256 hash of the first hash.
+  return SHA256Digest().process(tmp);
+}
+
+/// Function: singleHash
+/// Description: Computes a single SHA-256 hash of the input data.
+/// Input: Uint8List buffer - The data to be hashed.
+/// Output: Uint8List - The resulting single SHA-256 hash.
+/// Note: This function calculates a single SHA-256 hash of the input data.
+Uint8List singleHash(Uint8List buffer) {
+  /// Compute a single SHA-256 hash of the input data.
+  return SHA256Digest().process(buffer);
+}
+
+/// Function: taggedHash
+/// Description: Computes a tagged hash of the input data with a provided tag.
+/// Input:
+///   - Uint8List data - The data to be hashed.
+///   - String tag - A unique tag to differentiate the hash.
+/// Output: Uint8List - The resulting tagged hash.
+/// Note: This function combines the provided tag with the input data to create a unique
+/// hash by applying a double SHA-256 hash.
+Uint8List taggedHash(Uint8List data, String tag) {
+  /// Calculate the hash of the tag as Uint8List.
+  final tagDigest = singleHash(Uint8List.fromList(tag.codeUnits));
+
+  /// Concatenate the tag hash with itself and the input data.
+  final concat = Uint8List.fromList([...tagDigest, ...tagDigest, ...data]);
+
+  /// Compute a double SHA-256 hash of the concatenated data.
+  return singleHash(concat);
+}
diff --git a/lib/src/ec/ec_encryption.dart b/lib/src/ec/ec_encryption.dart
new file mode 100644
index 0000000..0986f19
--- /dev/null
+++ b/lib/src/ec/ec_encryption.dart
@@ -0,0 +1,293 @@
+import 'dart:typed_data';
+
+import 'package:bitcoin_flutter/src/utils/bigint.dart';
+import 'package:bitcoin_flutter/src/utils/uint8list.dart';
+import '../formatting/bytes_num_formatting.dart';
+import "package:pointycastle/ecc/curves/secp256k1.dart" show ECCurve_secp256k1;
+import 'package:pointycastle/ecc/api.dart' show ECPoint;
+import '../crypto.dart';
+
+final prime =
+    BigInt.parse("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F", radix: 16);
+
+final _zero32 = Uint8List(32);
+final _ecP = hexToBytes("fffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f");
+final secp256k1 = ECCurve_secp256k1();
+final n = secp256k1.n;
+final G = secp256k1.G;
+
+ECPoint? _decodeFrom(Uint8List P) {
+  return secp256k1.curve.decodePoint(P);
+}
+
+int _compare(Uint8List a, Uint8List b) {
+  final aa = a.bigint;
+  final bb = b.bigint;
+  if (aa == bb) return 0;
+  if (aa > bb) return 1;
+  return -1;
+}
+
+bool isPoint(Uint8List p) {
+  // Check if the input list has a length of at least 33 bytes, which is the minimum length required for a compressed representation of a point on the curve
+  if (p.length < 33) {
+    return false;
+  }
+
+  // Extract the first byte of the input list, which represents the type of the point
+  var t = p[0];
+
+  // Extract the next 32 bytes, which represent the X coordinate of the point
+  var x = p.sublist(1, 33);
+
+  // Check if the X coordinate is equal to zero or infinity, which are invalid values for a point on the curve
+  if (_compare(x, _zero32) == 0) {
+    return false;
+  }
+  if (_compare(x, _ecP) == 1) {
+    return false;
+  }
+
+  try {
+    _decodeFrom(p);
+  } catch (err) {
+    return false;
+  }
+
+  // Check if the point is a compressed representation of a point on the curve. If it is, return true.
+  if ((t == 0x02 || t == 0x03) && p.length == 33) {
+    return true;
+  }
+
+  // Extract the next 32 bytes, which represent the Y coordinate of the point
+  var y = p.sublist(33);
+
+  // Check if the Y coordinate is equal to zero or infinity, which are invalid values for a point on the curve
+  if (_compare(y, _zero32) == 0) {
+    return false;
+  }
+  if (_compare(y, _ecP) == 1) {
+    return false;
+  }
+
+  // Check if the point is an uncompressed representation of a point on the curve. If it is, return true
+  if (t == 0x04 && p.length == 65) {
+    return true;
+  }
+
+  // If the point is not a valid point on the curve, return false
+  return false;
+}
+
+bool _isPointCompressed(Uint8List p) {
+  return p[0] != 0x04;
+}
+
+Uint8List reEncodedFromForm(Uint8List p, bool compressed) {
+  final decode = _decodeFrom(p);
+  if (decode == null) {
+    throw ArgumentError("Bad point");
+  }
+  final encode = decode.getEncoded(compressed);
+  if (!_isPointCompressed(encode)) {
+    return encode.sublist(1, encode.length);
+  }
+
+  return encode;
+}
+
+Uint8List taprootPoint(Uint8List pub) {
+  BigInt x = decodeBigInt(pub.sublist(0, 32));
+  BigInt y = decodeBigInt(pub.sublist(32, pub.length));
+  if (y.isOdd) {
+    y = prime - y;
+  }
+
+  var Q = secp256k1.curve.createPoint(x, y);
+
+  if (Q.y!.toBigInteger()!.isOdd) {
+    y = prime - Q.y!.toBigInteger()!;
+    Q = secp256k1.curve.createPoint(Q.x!.toBigInteger()!, y);
+  }
+  x = Q.x!.toBigInteger()!;
+  y = Q.y!.toBigInteger()!;
+  final r = padUint8ListTo32(x.decode);
+  final s = padUint8ListTo32(y.decode);
+  return Uint8List.fromList([...r, ...s]);
+}
+
+Uint8List tweakTaprootPoint(Uint8List pub, Uint8List tweak) {
+  BigInt x = decodeBigInt(pub.sublist(0, 32));
+  BigInt y = decodeBigInt(pub.sublist(32, pub.length));
+  if (y.isOdd) {
+    y = prime - y;
+  }
+  final tw = decodeBigInt(tweak);
+
+  final c = secp256k1.curve.createPoint(x, y);
+  ECPoint qq = (G * tw) as ECPoint;
+  ECPoint Q = (c + qq) as ECPoint;
+
+  if (Q.y!.toBigInteger()!.isOdd) {
+    y = prime - Q.y!.toBigInteger()!;
+    Q = secp256k1.curve.createPoint(Q.x!.toBigInteger()!, y);
+  }
+  x = Q.x!.toBigInteger()!;
+  y = Q.y!.toBigInteger()!;
+  final r = padUint8ListTo32(x.decode);
+  final s = padUint8ListTo32(y.decode);
+  return Uint8List.fromList([...r, ...s]);
+}
+
+Uint8List xorBytes(Uint8List a, Uint8List b) {
+  if (a.length != b.length) {
+    throw ArgumentError("Input lists must have the same length");
+  }
+
+  Uint8List result = Uint8List(a.length);
+
+  for (int i = 0; i < a.length; i++) {
+    result[i] = a[i] ^ b[i];
+  }
+
+  return result;
+}
+
+Uint8List schnorrSign(Uint8List msg, Uint8List secret, Uint8List aux) {
+  if (msg.length != 32) {
+    throw ArgumentError("The message must be a 32-byte array.");
+  }
+  final d0 = decodeBigInt(secret);
+  if (!(BigInt.one <= d0 && d0 <= n - BigInt.one)) {
+    throw ArgumentError("The secret key must be an integer in the range 1..n-1.");
+  }
+  if (aux.length != 32) {
+    throw ArgumentError("aux_rand must be 32 bytes instead of ${aux.length}");
+  }
+  ECPoint P = (G * d0) as ECPoint;
+  BigInt d = d0;
+  if (P.y!.toBigInteger()!.isOdd) {
+    d = n - d;
+  }
+  final t = xorBytes(d.decode, taggedHash(aux, "BIP0340/aux"));
+  final kHash = taggedHash(
+      Uint8List.fromList([...t, ...P.x!.toBigInteger()!.decode, ...msg]), "BIP0340/nonce");
+  final k0 = decodeBigInt(kHash) % n;
+  if (k0 == BigInt.zero) {
+    throw const FormatException('Failure. This happens only with negligible probability.');
+  }
+  final R = (G * k0) as ECPoint;
+  BigInt k = k0;
+  if (R.y!.toBigInteger()!.isOdd) {
+    k = n - k;
+  }
+  final eHash = taggedHash(
+      Uint8List.fromList([...R.x!.toBigInteger()!.decode, ...P.x!.toBigInteger()!.decode, ...msg]),
+      "BIP0340/challenge");
+
+  final e = decodeBigInt(eHash) % n;
+  final eKey = (k + e * d) % n;
+  final sig = Uint8List.fromList([...R.x!.toBigInteger()!.decode, ...eKey.decode]);
+  final verify = verifySchnorr(msg, P.x!.toBigInteger()!.decode, sig);
+  if (!verify) {
+    throw const FormatException('The created signature does not pass verification.');
+  }
+  return sig;
+}
+
+bool verifySchnorr(Uint8List message, Uint8List publicKey, Uint8List signatur) {
+  if (message.length != 32) {
+    throw ArgumentError("The message must be a 32-byte array.");
+  }
+  if (publicKey.length != 32) {
+    throw ArgumentError("The public key must be a 32-byte array.");
+  }
+  if (signatur.length != 64) {
+    throw ArgumentError("The signature must be a 64-byte array.");
+  }
+  final P = liftX(decodeBigInt(publicKey));
+  final r = decodeBigInt(signatur.sublist(0, 32));
+  final s = decodeBigInt(signatur.sublist(32, 64));
+  if (P == null || r >= prime || s >= n) {
+    return false;
+  }
+  final eHash = taggedHash(
+      Uint8List.fromList([...signatur.sublist(0, 32), ...publicKey, ...message]),
+      "BIP0340/challenge");
+  final e = decodeBigInt(eHash) % n;
+
+  final sp = (G * s) as ECPoint;
+
+  final eP = (P * (n - e)) as ECPoint;
+
+  final R = (sp + eP) as ECPoint;
+  if (R.y!.toBigInteger()!.isOdd || R.x!.toBigInteger()! != r) {
+    return false;
+  }
+  return true;
+}
+
+ECPoint? liftX(BigInt x) {
+  if (x >= prime) {
+    return null;
+  }
+  final ySq = (_modPow(x, BigInt.from(3), prime) + BigInt.from(7)) % prime;
+  final y = _modPow(ySq, (prime + BigInt.one) ~/ BigInt.from(4), prime);
+  if (_modPow(y, BigInt.two, prime) != ySq) return null;
+  BigInt result = (y & BigInt.one) == BigInt.zero ? y : prime - y;
+  return secp256k1.curve.createPoint(x, result);
+}
+
+BigInt _modPow(BigInt base, BigInt exponent, BigInt modulus) {
+  if (exponent == BigInt.zero) {
+    return BigInt.one;
+  }
+
+  BigInt result = BigInt.one;
+  base %= modulus;
+
+  while (exponent > BigInt.zero) {
+    if ((exponent & BigInt.one) == BigInt.one) {
+      result = (result * base) % modulus;
+    }
+    exponent = exponent ~/ BigInt.two;
+    base = (base * base) % modulus;
+  }
+
+  return result;
+}
+
+Uint8List pubKeyGeneration(Uint8List secret) {
+  final d0 = decodeBigInt(secret);
+  if (!(BigInt.one <= d0 && d0 <= n - BigInt.one)) {
+    throw ArgumentError("The secret key must be an integer in the range 1..n-1.");
+  }
+  ECPoint qq = (G * d0) as ECPoint;
+  Uint8List toBytes = qq.getEncoded(false);
+  if (toBytes[0] == 0x04) {
+    toBytes = toBytes.sublist(1, toBytes.length);
+  }
+  return toBytes;
+}
+
+BigInt _negatePrivateKey(Uint8List secret) {
+  final bytes = pubKeyGeneration(secret);
+  final toBigInt = decodeBigInt(bytes.sublist(32));
+  BigInt negatedKey = decodeBigInt(secret);
+  if (toBigInt.isOdd) {
+    final keyExpend = decodeBigInt(secret);
+    negatedKey = n - keyExpend;
+  }
+  return negatedKey;
+}
+
+Uint8List tweekTapprotPrivate(Uint8List secret, BigInt tweek) {
+  final bytes = pubKeyGeneration(secret);
+  final toBigInt = decodeBigInt(bytes.sublist(32));
+  BigInt negatedKey = decodeBigInt(secret);
+  if (toBigInt.isOdd) {
+    negatedKey = _negatePrivateKey(secret);
+  }
+  final tw = (negatedKey + tweek) % n;
+  return tw.decode;
+}
diff --git a/lib/src/ec/ec_public.dart b/lib/src/ec/ec_public.dart
new file mode 100644
index 0000000..e91af2a
--- /dev/null
+++ b/lib/src/ec/ec_public.dart
@@ -0,0 +1,237 @@
+import 'dart:typed_data';
+import '../payments/address/address.dart';
+import '../payments/address/core.dart';
+import '../payments/address/segwit_address.dart';
+import '../payments/constants/constants.dart';
+import 'package:bitcoin_flutter/src/payments/script/script.dart';
+import '../crypto.dart';
+import '../formatting/bytes_num_formatting.dart';
+import 'ec_encryption.dart';
+
+class ECPublic {
+  /// Constructs an ECPublic key from a byte representation.
+  ECPublic.fromBytes(Uint8List public) {
+    if (!isPoint(public)) {
+      throw ArgumentError("Bad point");
+    }
+    final d = reEncodedFromForm(public, false);
+    _key = d;
+  }
+
+  /// Constructs an ECPublic key from hex representation.
+  ECPublic.fromHex(String hex) {
+    final toBytes = hexToBytes(hex);
+    if (!isPoint(toBytes)) {
+      throw ArgumentError("Bad point");
+    }
+    final d = reEncodedFromForm(toBytes, false);
+    _key = d;
+  }
+
+  late final Uint8List _key;
+
+  /// toHex converts the ECPublic key to a hex-encoded string.
+  /// If 'compressed' is true, the key is in compressed format.
+  String toHex({bool compressed = true}) {
+    final bytes = toBytes();
+    if (compressed) {
+      final point = reEncodedFromForm(bytes, true);
+      return bytesToHex(point);
+    }
+    return bytesToHex(bytes);
+  }
+
+  /// _toHash160 computes the RIPEMD160 hash of the ECPublic key.
+  /// If 'compressed' is true, the key is in compressed format.
+  Uint8List _toHash160({bool compressed = true}) {
+    final bytes = hexToBytes(toHex(compressed: compressed));
+    return hash160(bytes);
+  }
+
+  /// toHash160 computes the RIPEMD160 hash of the ECPublic key.
+  /// If 'compressed' is true, the key is in compressed format.
+  String toHash160({bool compressed = true}) {
+    final bytes = hexToBytes(toHex(compressed: compressed));
+    return bytesToHex(hash160(bytes));
+  }
+
+  /// toAddress generates a P2PKH (Pay-to-Public-Key-Hash) address from the ECPublic key.
+  /// If 'compressed' is true, the key is in compressed format.
+  P2pkhAddress toAddress({bool compressed = true}) {
+    final h16 = _toHash160(compressed: compressed);
+    final toHex = bytesToHex(h16);
+
+    return P2pkhAddress(hash160: toHex);
+  }
+
+  /// toSegwitAddress generates a P2WPKH (Pay-to-Witness-Public-Key-Hash) SegWit address
+  /// from the ECPublic key. If 'compressed' is true, the key is in compressed format.
+  P2wpkhAddress toSegwitAddress({bool compressed = true}) {
+    final h16 = _toHash160(compressed: compressed);
+    final toHex = bytesToHex(h16);
+
+    return P2wpkhAddress(program: toHex);
+  }
+
+  /// toP2pkAddress generates a P2PK (Pay-to-Public-Key) address from the ECPublic key.
+  /// If 'compressed' is true, the key is in compressed format.
+  P2pkAddress toP2pkAddress({bool compressed = true}) {
+    final h = toHex(compressed: compressed);
+    return P2pkAddress(pubkey: h);
+  }
+
+  /// toRedeemScript generates a redeem script from the ECPublic key.
+  /// If 'compressed' is true, the key is in compressed format.
+  Script toRedeemScript({bool compressed = true}) {
+    final redeem = toHex(compressed: compressed);
+    return Script(script: [redeem, "OP_CHECKSIG"]);
+  }
+
+  /// toP2pkhInP2sh generates a P2SH (Pay-to-Script-Hash) address
+  /// wrapping a P2PK (Pay-to-Public-Key) script derived from the ECPublic key.
+  /// If 'compressed' is true, the key is in compressed format.
+  P2shAddress toP2pkhInP2sh({bool compressed = true}) {
+    final addr = toAddress(compressed: compressed);
+    return P2shAddress.fromScript(scriptPubKey: addr.scriptPubkey, type: AddressType.p2pkhInP2sh);
+  }
+
+  /// toP2pkInP2sh generates a P2SH (Pay-to-Script-Hash) address
+  /// wrapping a P2PK (Pay-to-Public-Key) script derived from the ECPublic key.
+  /// If 'compressed' is true, the key is in compressed format.
+  P2shAddress toP2pkInP2sh({bool compressed = true}) {
+    return P2shAddress(scriptPubKey: toRedeemScript(compressed: compressed));
+  }
+
+  /// ToTaprootAddress generates a P2TR(Taproot) address from the ECPublic key
+  /// and an optional script. The 'script' parameter can be used to specify
+  /// custom spending conditions.
+  P2trAddress toTaprootAddress({List<dynamic>? scripts}) {
+    final pubKey = toTapRotHex(script: scripts);
+
+    return P2trAddress(program: pubKey);
+  }
+
+  /// toP2wpkhInP2sh generates a P2SH (Pay-to-Script-Hash) address
+  /// wrapping a P2WPKH (Pay-to-Witness-Public-Key-Hash) script derived from the ECPublic key.
+  /// If 'compressed' is true, the key is in compressed format.
+  P2shAddress toP2wpkhInP2sh({bool compressed = true}) {
+    final addr = toSegwitAddress(compressed: compressed);
+    return P2shAddress.fromScript(scriptPubKey: addr.scriptPubkey, type: AddressType.p2wpkhInP2sh);
+  }
+
+  /// toP2wshScript generates a P2WSH (Pay-to-Witness-Script-Hash) script
+  /// derived from the ECPublic key. If 'compressed' is true, the key is in compressed format.
+  Script toP2wshScript({bool compressed = true}) {
+    return Script(script: ['OP_1', toHex(compressed: compressed), "OP_1", "OP_CHECKMULTISIG"]);
+  }
+
+  /// toP2wshAddress generates a P2WSH (Pay-to-Witness-Script-Hash) address
+  /// from the ECPublic key. If 'compressed' is true, the key is in compressed format.
+  P2wshAddress toP2wshAddress({bool compressed = true}) {
+    return P2wshAddress(script: toP2wshScript(compressed: compressed));
+  }
+
+  /// toP2wshInP2sh generates a P2SH (Pay-to-Script-Hash) address
+  /// wrapping a P2WSH (Pay-to-Witness-Script-Hash) script derived from the ECPublic key.
+  /// If 'compressed' is true, the key is in compressed format.
+  P2shAddress toP2wshInP2sh({bool compressed = true}) {
+    final p2sh = toP2wshAddress(compressed: compressed);
+    return P2shAddress.fromScript(scriptPubKey: p2sh.scriptPubkey, type: AddressType.p2wshInP2sh);
+  }
+
+  /// calculateTweek computes and returns the TapTweak value based on the ECPublic key
+  /// and an optional script. It uses the key's x-coordinate and the Merkle root of the script
+  /// (if provided) to calculate the tweak.
+  BigInt calculateTweek({dynamic script}) {
+    final tweak = _calculateTweek(_key, script: script);
+    return decodeBigInt(tweak);
+  }
+
+  /// toBytes returns the uncompressed byte representation of the ECPublic key.
+  Uint8List toBytes({int? prefix = 0x04}) {
+    if (prefix != null) {
+      return Uint8List.fromList([prefix, ..._key]);
+    }
+    return Uint8List.fromList([..._key]);
+  }
+
+  /// toCompressedBytes returns the compressed byte representation of the ECPublic key.
+  Uint8List toCompressedBytes() {
+    final point = reEncodedFromForm(toBytes(), true);
+    return point;
+  }
+
+  /// returns the x coordinate only as hex string after tweaking (needed for taproot)
+  String toTapPoint() {
+    final point = taprootPoint(_key);
+    return bytesToHex(point.sublist(0, 32));
+  }
+
+  /// returns the x coordinate only as hex string after tweaking (needed for taproot)
+  String toTapRotHex({List<dynamic>? script}) {
+    final tweak = _calculateTweek(_key, script: script);
+    final point = tweakTaprootPoint(_key, tweak);
+    return bytesToHex(point.sublist(0, 32));
+  }
+
+  /// toXOnlyHex extracts and returns the x-coordinate (first 32 bytes) of the ECPublic key
+  /// as a hexadecimal string.
+  String toXOnlyHex() {
+    return bytesToHex(_key.sublist(0, 32));
+  }
+
+  /// _calculateTweek computes and returns the TapTweak value based on the ECPublic key
+  /// and an optional script. It uses the key's x-coordinate and the Merkle root of the script
+  /// (if provided) to calculate the tweak.
+  Uint8List _calculateTweek(Uint8List public, {dynamic script}) {
+    final keyX = Uint8List.fromList(public.getRange(0, 32).toList());
+    if (script == null) {
+      final tweek = taggedHash(keyX, "TapTweak");
+      return tweek;
+    }
+    final merkleRoot = _getTagHashedMerkleRoot(script);
+    final tweek = taggedHash(Uint8List.fromList([...keyX, ...merkleRoot]), "TapTweak");
+    return tweek;
+  }
+
+  /// _getTagHashedMerkleRoot computes and returns the tagged hashed Merkle root for Taproot
+  /// based on the provided argument. It handles different argument types, including scripts
+  /// and lists of scripts.
+  Uint8List _getTagHashedMerkleRoot(dynamic args) {
+    if (args is Script) {
+      final tagged = _tapleafTaggedHash(args);
+      return tagged;
+    }
+
+    args as List;
+    if (args.isEmpty) return Uint8List(0);
+    if (args.length == 1) {
+      return _getTagHashedMerkleRoot(args.first);
+    } else if (args.length == 2) {
+      final left = _getTagHashedMerkleRoot(args.first);
+      final right = _getTagHashedMerkleRoot(args.last);
+      final tap = _tapBranchTaggedHash(left, right);
+      return tap;
+    }
+    throw Exception("List cannot have more than 2 branches.");
+  }
+
+  /// _tapleafTaggedHash computes and returns the tagged hash of a script for Taproot,
+  /// using the specified script. It prepends a version byte and then tags the hash with "TapLeaf".
+  Uint8List _tapleafTaggedHash(Script script) {
+    final scriptBytes = prependVarint(script.toBytes());
+
+    final part = Uint8List.fromList([LEAF_VERSION_TAPSCRIPT, ...scriptBytes]);
+    return taggedHash(part, 'TapLeaf');
+  }
+
+  /// _tapBranchTaggedHash computes and returns the tagged hash of two byte slices
+  /// for Taproot, where 'a' and 'b' are the input byte slices. It ensures that 'a' and 'b'
+  /// are sorted and concatenated before tagging the hash with "TapBranch".
+  Uint8List _tapBranchTaggedHash(Uint8List a, Uint8List b) {
+    if (isLessThanBytes(a, b)) {
+      return taggedHash(Uint8List.fromList([...a, ...b]), "TapBranch");
+    }
+    return taggedHash(Uint8List.fromList([...b, ...a]), "TapBranch");
+  }
+}
diff --git a/lib/src/ec/schnorr.dart b/lib/src/ec/schnorr.dart
new file mode 100644
index 0000000..4da662e
--- /dev/null
+++ b/lib/src/ec/schnorr.dart
@@ -0,0 +1,80 @@
+import 'dart:typed_data';
+import 'package:bitcoin_flutter/src/crypto.dart';
+import 'package:bitcoin_flutter/src/formatting/bytes_num_formatting.dart';
+import 'package:bitcoin_flutter/src/ec/ec_encryption.dart';
+import 'package:bitcoin_flutter/src/utils/bigint.dart';
+import 'package:pointycastle/ecc/api.dart' show ECPoint;
+
+Uint8List schnorrSign(Uint8List msg, Uint8List secret, Uint8List aux) {
+  if (msg.length != 32) {
+    throw ArgumentError("The message must be a 32-byte array.");
+  }
+  final d0 = decodeBigInt(secret);
+  if (!(BigInt.one <= d0 && d0 <= n - BigInt.one)) {
+    throw ArgumentError("The secret key must be an integer in the range 1..n-1.");
+  }
+  if (aux.length != 32) {
+    throw ArgumentError("aux_rand must be 32 bytes instead of ${aux.length}");
+  }
+  ECPoint P = (G * d0) as ECPoint;
+  BigInt d = d0;
+  if (P.y!.toBigInteger()!.isOdd) {
+    d = n - d;
+  }
+  final t = xorBytes(d.decode, taggedHash(aux, "BIP0340/aux"));
+  final kHash = taggedHash(
+      Uint8List.fromList([...t, ...P.x!.toBigInteger()!.decode, ...msg]), "BIP0340/nonce");
+  final k0 = decodeBigInt(kHash) % n;
+  if (k0 == BigInt.zero) {
+    throw const FormatException('Failure. This happens only with negligible probability.');
+  }
+  final R = (G * k0) as ECPoint;
+  BigInt k = k0;
+  if (R.y!.toBigInteger()!.isOdd) {
+    k = n - k;
+  }
+  final eHash = taggedHash(
+      Uint8List.fromList([...R.x!.toBigInteger()!.decode, ...P.x!.toBigInteger()!.decode, ...msg]),
+      "BIP0340/challenge");
+
+  final e = decodeBigInt(eHash) % n;
+  final eKey = (k + e * d) % n;
+  final sig = Uint8List.fromList([...R.x!.toBigInteger()!.decode, ...eKey.decode]);
+  final verify = verifySchnorr(msg, P.x!.toBigInteger()!.decode, sig);
+  if (!verify) {
+    throw const FormatException('The created signature does not pass verification.');
+  }
+  return sig;
+}
+
+bool verifySchnorr(Uint8List message, Uint8List publicKey, Uint8List signatur) {
+  if (message.length != 32) {
+    throw ArgumentError("The message must be a 32-byte array.");
+  }
+  if (publicKey.length != 32) {
+    throw ArgumentError("The public key must be a 32-byte array.");
+  }
+  if (signatur.length != 64) {
+    throw ArgumentError("The signature must be a 64-byte array.");
+  }
+  final P = liftX(decodeBigInt(publicKey));
+  final r = decodeBigInt(signatur.sublist(0, 32));
+  final s = decodeBigInt(signatur.sublist(32, 64));
+  if (P == null || r >= prime || s >= n) {
+    return false;
+  }
+  final eHash = taggedHash(
+      Uint8List.fromList([...signatur.sublist(0, 32), ...publicKey, ...message]),
+      "BIP0340/challenge");
+  final e = decodeBigInt(eHash) % n;
+
+  final sp = (G * s) as ECPoint;
+
+  final eP = (P * (n - e)) as ECPoint;
+
+  final R = (sp + eP) as ECPoint;
+  if (R.y!.toBigInteger()!.isOdd || R.x!.toBigInteger()! != r) {
+    return false;
+  }
+  return true;
+}
diff --git a/lib/src/ecpair.dart b/lib/src/ecpair.dart
index ee27339..6694594 100644
--- a/lib/src/ecpair.dart
+++ b/lib/src/ecpair.dart
@@ -2,7 +2,11 @@ import 'dart:typed_data';
 import 'dart:math';
 import 'package:bip32/src/utils/ecurve.dart' as ecc;
 import 'package:bip32/src/utils/wif.dart' as wif;
-import 'models/networks.dart';
+import 'package:bitcoin_flutter/src/models/networks.dart';
+import 'package:bitcoin_flutter/src/payments/constants/constants.dart';
+import 'ec/ec_public.dart';
+import 'ec/ec_encryption.dart' as ec;
+import 'crypto.dart' as bcrypto;
 
 class ECPair {
   Uint8List? _d;
@@ -10,8 +14,8 @@ class ECPair {
   NetworkType network;
   bool compressed;
   ECPair(Uint8List? _d, Uint8List? _Q, {NetworkType? network, bool? compressed})
-  : this.network = network ?? bitcoin,
-    this.compressed = compressed ?? true {
+      : this.network = network ?? bitcoin,
+        this.compressed = compressed ?? true {
     this._d = _d;
     this._Q = _Q;
   }
@@ -25,8 +29,8 @@ class ECPair {
     if (privateKey == null) {
       throw new ArgumentError('Missing private key');
     }
-    return wif.encode(new wif.WIF(
-        version: network.wif, privateKey: privateKey!, compressed: compressed));
+    return wif
+        .encode(new wif.WIF(version: network.wif, privateKey: privateKey!, compressed: compressed));
   }
 
   Uint8List sign(Uint8List hash) {
@@ -54,29 +58,21 @@ class ECPair {
         throw new ArgumentError('Unknown network version');
       }
     }
-    return ECPair.fromPrivateKey(decoded.privateKey,
-        compressed: decoded.compressed, network: nw);
+    return ECPair.fromPrivateKey(decoded.privateKey, compressed: decoded.compressed, network: nw);
   }
-  factory ECPair.fromPublicKey(Uint8List publicKey,
-      {NetworkType? network, bool? compressed}) {
+  factory ECPair.fromPublicKey(Uint8List publicKey, {NetworkType? network, bool? compressed}) {
     if (!ecc.isPoint(publicKey)) {
       throw new ArgumentError('Point is not on the curve');
     }
-    return new ECPair(null, publicKey,
-        network: network, compressed: compressed);
+    return new ECPair(null, publicKey, network: network, compressed: compressed);
   }
-  factory ECPair.fromPrivateKey(Uint8List privateKey,
-      {NetworkType? network, bool? compressed}) {
+  factory ECPair.fromPrivateKey(Uint8List privateKey, {NetworkType? network, bool? compressed}) {
     if (privateKey.length != 32)
-      throw new ArgumentError(
-          'Expected property privateKey of type Buffer(Length: 32)');
-    if (!ecc.isPrivate(privateKey))
-      throw new ArgumentError('Private key not in range [1, n)');
-    return new ECPair(privateKey, null,
-        network: network, compressed: compressed);
+      throw new ArgumentError('Expected property privateKey of type Buffer(Length: 32)');
+    if (!ecc.isPrivate(privateKey)) throw new ArgumentError('Private key not in range [1, n)');
+    return new ECPair(privateKey, null, network: network, compressed: compressed);
   }
-  factory ECPair.makeRandom(
-      {NetworkType? network, bool? compressed, Function? rng}) {
+  factory ECPair.makeRandom({NetworkType? network, bool? compressed, Function? rng}) {
     final rfunc = rng ?? _randomBytes;
     Uint8List d;
 //    int beginTime = DateTime.now().millisecondsSinceEpoch;
@@ -87,6 +83,25 @@ class ECPair {
     } while (!ecc.isPrivate(d));
     return ECPair.fromPrivateKey(d, network: network, compressed: compressed);
   }
+
+  /// sign taproot transaction digest and returns the signature.
+  Uint8List signTapRoot(Uint8List txDigest,
+      {int sighash = TAPROOT_SIGHASH_ALL, List<dynamic> scripts = const [], bool tweak = true}) {
+    Uint8List byteKey = Uint8List(0);
+    if (tweak) {
+      final ECPublic publicKey = ECPublic.fromBytes(_Q!);
+      final t = publicKey.calculateTweek(script: scripts);
+      byteKey = ec.tweekTapprotPrivate(_d!, t);
+    } else {
+      byteKey = _d!;
+    }
+    final randAux = bcrypto.singleHash(Uint8List.fromList([...txDigest, ...byteKey]));
+    Uint8List signatur = ec.schnorrSign(txDigest, byteKey, randAux);
+    if (sighash != TAPROOT_SIGHASH_ALL) {
+      signatur = Uint8List.fromList([...signatur, sighash]);
+    }
+    return signatur;
+  }
 }
 
 const int _SIZE_BYTE = 255;
diff --git a/lib/src/formatting/bytes_num_formatting.dart b/lib/src/formatting/bytes_num_formatting.dart
new file mode 100644
index 0000000..342381b
--- /dev/null
+++ b/lib/src/formatting/bytes_num_formatting.dart
@@ -0,0 +1,208 @@
+import 'dart:core';
+import 'dart:typed_data';
+import 'package:convert/convert.dart';
+
+/// ignore: implementation_imports
+import 'package:pointycastle/src/utils.dart' as p_utils;
+import 'package:bitcoin_flutter/src/utils/string.dart';
+
+String bytesToHex(
+  List<int> bytes,
+) =>
+    hex.encode(bytes);
+
+BigInt bytesToInt(List<int> bytes) => p_utils.decodeBigInt(bytes);
+
+Uint8List intToBytes(BigInt number) => p_utils.encodeBigInt(number);
+
+Uint8List padUint8ListTo32(Uint8List data) {
+  assert(data.length <= 32);
+  if (data.length == 32) return data;
+
+  /// todo there must be a faster way to do this?
+  return Uint8List(32)..setRange(32 - data.length, 32, data);
+}
+
+bool isLessThanBytes(List<int> thashedA, List<int> thashedB) {
+  for (int i = 0; i < thashedA.length && i < thashedB.length; i++) {
+    if (thashedA[i] < thashedB[i]) {
+      return true;
+    } else if (thashedA[i] > thashedB[i]) {
+      return false;
+    }
+  }
+  return thashedA.length < thashedB.length;
+}
+
+BigInt decodeBigInt(List<int> bytes) {
+  BigInt result = BigInt.from(0);
+  for (int i = 0; i < bytes.length; i++) {
+    result += BigInt.from(bytes[bytes.length - i - 1]) << (8 * i);
+  }
+  return result;
+}
+
+List<int>? convertBits(List<int> data, int fromBits, int toBits, {bool pad = true}) {
+  int acc = 0;
+  int bits = 0;
+  List<int> ret = [];
+  int maxv = (1 << toBits) - 1;
+  int maxAcc = (1 << (fromBits + toBits - 1)) - 1;
+
+  for (int value in data) {
+    if (value < 0 || (value >> fromBits) > 0) {
+      return null;
+    }
+    acc = ((acc << fromBits) | value) & maxAcc;
+    bits += fromBits;
+    while (bits >= toBits) {
+      bits -= toBits;
+      ret.add((acc >> bits) & maxv);
+    }
+  }
+
+  if (pad) {
+    if (bits > 0) {
+      ret.add((acc << (toBits - bits)) & maxv);
+    }
+  } else if (bits >= fromBits || ((acc << (toBits - bits)) & maxv) > 0) {
+    return null;
+  }
+
+  return ret;
+}
+
+Uint8List encodeVarint(int i) {
+  if (i < 253) {
+    return Uint8List.fromList([i]);
+  } else if (i < 0x10000) {
+    final bytes = Uint8List(3);
+    bytes[0] = 0xfd;
+    ByteData.view(bytes.buffer).setUint16(1, i, Endian.little);
+    return bytes;
+  } else if (i < 0x100000000) {
+    final bytes = Uint8List(5);
+    bytes[0] = 0xfe;
+    ByteData.view(bytes.buffer).setUint32(1, i, Endian.little);
+    return bytes;
+  } else if (BigInt.from(i) < BigInt.parse("0x10000000000000000", radix: 16)) {
+    final bytes = Uint8List(9);
+    bytes[0] = 0xff;
+    ByteData.view(bytes.buffer).setUint64(1, i, Endian.little);
+    return bytes;
+  } else {
+    throw ArgumentError("Integer is too large: $i");
+  }
+}
+
+Uint8List prependVarint(Uint8List data) {
+  final varintBytes = encodeVarint(data.length);
+  return Uint8List.fromList([...varintBytes, ...data]);
+}
+
+(int, int) viToInt(Uint8List byteint) {
+  int ni = byteint[0];
+  int size = 0;
+
+  if (ni < 253) {
+    return (ni, 1);
+  }
+
+  if (ni == 253) {
+    size = 2;
+  } else if (ni == 254) {
+    size = 4;
+  } else {
+    size = 8;
+  }
+
+  int value = ByteData.sublistView(byteint, 1, 1 + size).getInt64(0, Endian.little);
+  return (value, size + 1);
+}
+
+Uint8List packUint32LE(int value) {
+  final byteData = ByteData(4);
+  byteData.setUint32(0, value, Endian.little);
+  return byteData.buffer.asUint8List();
+}
+
+Uint8List packBigIntToLittleEndian(BigInt value) {
+  final buffer = Uint8List(8);
+
+  for (var i = 0; i < 8; i++) {
+    buffer[i] = (value & BigInt.from(0xff)).toInt();
+    value >>= 8;
+  }
+
+  return buffer;
+}
+
+Uint8List packInt32LE(int value) {
+  final byteData = ByteData(4);
+  byteData.setInt32(0, value, Endian.little);
+  return byteData.buffer.asUint8List();
+}
+
+String strip0x(String hex) {
+  if (hex.startsWith('0x')) return hex.substring(2);
+  return hex;
+}
+
+Uint8List hexToBytes(String hexStr) {
+  return strip0x(hexStr).fromHex;
+}
+
+int intFromBytes(List<int> bytes, Endian endian) {
+  if (bytes.isEmpty) {
+    throw ArgumentError("Input bytes should not be empty");
+  }
+
+  final buffer = Uint8List.fromList(bytes);
+  final byteData = ByteData.sublistView(buffer);
+
+  switch (bytes.length) {
+    case 1:
+      return byteData.getInt8(0);
+    case 2:
+      return byteData.getInt16(0, endian);
+    case 4:
+      return byteData.getInt32(0, endian);
+    default:
+      throw ArgumentError("Unsupported byte length: ${bytes.length}");
+  }
+}
+
+bool bytesListEqual(List<int>? a, List<int>? b) {
+  if (a == null) {
+    return b == null;
+  }
+  if (b == null || a.length != b.length) {
+    return false;
+  }
+  if (identical(a, b)) {
+    return true;
+  }
+  for (int index = 0; index < a.length; index += 1) {
+    if (a[index] != b[index]) {
+      return false;
+    }
+  }
+  return true;
+}
+
+Uint8List packUint32BE(int value) {
+  var bytes = Uint8List(4);
+  bytes[0] = (value >> 24) & 0xFF;
+  bytes[1] = (value >> 16) & 0xFF;
+  bytes[2] = (value >> 8) & 0xFF;
+  bytes[3] = value & 0xFF;
+  return bytes;
+}
+
+int binaryToByte(String binary) {
+  return int.parse(binary, radix: 2);
+}
+
+String bytesToBinary(Uint8List bytes) {
+  return bytes.map((byte) => byte.toRadixString(2).padLeft(8, '0')).join('');
+}
diff --git a/lib/src/formatting/bytes_tracker.dart b/lib/src/formatting/bytes_tracker.dart
new file mode 100644
index 0000000..f49049c
--- /dev/null
+++ b/lib/src/formatting/bytes_tracker.dart
@@ -0,0 +1,26 @@
+import 'dart:convert';
+import 'dart:typed_data';
+import 'package:typed_data/typed_buffers.dart';
+
+class DynamicByteTracker extends ByteConversionSinkBase {
+  final Uint8Buffer _buffer = Uint8Buffer();
+  int _length = 0;
+
+  int get length => _length;
+
+  Uint8List toBytes() {
+    return _buffer.buffer.asUint8List(0, _length);
+  }
+
+  @override
+  void add(List<int> chunk) {
+    _buffer.addAll(chunk);
+    _length += chunk.length;
+  }
+
+  @override
+  void close() {
+    /// dont need
+  }
+}
+
diff --git a/lib/src/models/networks.dart b/lib/src/models/networks.dart
index be39874..32671ef 100644
--- a/lib/src/models/networks.dart
+++ b/lib/src/models/networks.dart
@@ -1,52 +1,154 @@
-import 'package:meta/meta.dart';
+import 'dart:typed_data';
+import '../payments/address/core.dart';
+import '../formatting/bytes_num_formatting.dart';
+
+enum BtcNetwork { mainnet, testnet }
+
+class Bip32Type {
+  final int public;
+  final int private;
+
+  const Bip32Type({required this.public, required this.private});
+
+  @override
+  String toString() {
+    return 'Bip32Type{public: $public, private: $private}';
+  }
+}
 
 class NetworkType {
-  String messagePrefix;
-  String bech32;
-  Bip32Type bip32;
-  int pubKeyHash;
-  int scriptHash;
-  int wif;
-
-  NetworkType(
+  final String messagePrefix;
+  final String bech32;
+  final Bip32Type bip32;
+  final int pubKeyHash;
+  final int scriptHash;
+  final int wif;
+  final int p2pkhPrefix;
+  final int p2shPrefix;
+  final BtcNetwork network;
+  final Map<AddressType, String> extendPrivate;
+  final Map<AddressType, String> extendPublic;
+  bool get isMainnet => network == BtcNetwork.mainnet;
+
+  const NetworkType(
       {required this.messagePrefix,
       String? bech32,
       required this.bip32,
       required this.pubKeyHash,
       required this.scriptHash,
-      required this.wif})
+      required this.wif,
+      required this.p2pkhPrefix,
+      required this.p2shPrefix,
+      required this.extendPrivate,
+      required this.extendPublic,
+      required this.network})
       : this.bech32 = bech32 ?? '';
 
-  @override
-  String toString() {
-    return 'NetworkType{messagePrefix: $messagePrefix, bech32: $bech32, bip32: ${bip32.toString()}, pubKeyHash: $pubKeyHash, scriptHash: $scriptHash, wif: $wif}';
+  static const BITCOIN = NetworkType(
+      messagePrefix: '\x18Bitcoin Signed Message:\n',
+      bech32: 'bc',
+      bip32: const Bip32Type(public: 0x0488b21e, private: 0x0488ade4),
+      pubKeyHash: 0x00,
+      scriptHash: 0x05,
+      wif: 0x80,
+      network: BtcNetwork.mainnet,
+      p2pkhPrefix: 0x00,
+      p2shPrefix: 0x05,
+      extendPrivate: {
+        AddressType.p2pkh: "0x0488ade4",
+        AddressType.p2pkhInP2sh: "0x0488ade4",
+        AddressType.p2wpkh: "0x04b2430c",
+        AddressType.p2wpkhInP2sh: "0x049d7878",
+        AddressType.p2wsh: "0x02aa7a99",
+        AddressType.p2wshInP2sh: "0x0295b005"
+      },
+      extendPublic: {
+        AddressType.p2pkh: "0x0488b21e",
+        AddressType.p2pkhInP2sh: "0x0488b21e",
+        AddressType.p2wpkh: "0x04b24746",
+        AddressType.p2wpkhInP2sh: "0x049d7cb2",
+        AddressType.p2wsh: "0x02aa7ed3",
+        AddressType.p2wshInP2sh: "0x0295b43f"
+      });
+
+  static const TESTNET = NetworkType(
+      messagePrefix: '\x18Bitcoin Signed Message:\n',
+      bech32: 'tb',
+      bip32: const Bip32Type(public: 0x043587cf, private: 0x04358394),
+      pubKeyHash: 0x6f,
+      scriptHash: 0xc4,
+      wif: 0xef,
+      network: BtcNetwork.testnet,
+      p2pkhPrefix: 0x6f,
+      p2shPrefix: 0xc4,
+      extendPrivate: {
+        AddressType.p2pkh: "0x04358394",
+        AddressType.p2pkhInP2sh: "0x04358394",
+        AddressType.p2wpkh: "0x045f18bc",
+        AddressType.p2wpkhInP2sh: "0x044a4e28",
+        AddressType.p2wsh: "0x02575048",
+        AddressType.p2wshInP2sh: "0x024285b5"
+      },
+      extendPublic: {
+        AddressType.p2pkh: "0x043587cf",
+        AddressType.p2pkhInP2sh: "0x043587cf",
+        AddressType.p2wpkh: "0x045f1cf6",
+        AddressType.p2wpkhInP2sh: "0x044a5262",
+        AddressType.p2wsh: "0x02575483",
+        AddressType.p2wshInP2sh: "0x024289ef"
+      });
+
+  static NetworkType networkFromWif(String wif) {
+    final w = int.parse(wif, radix: 16);
+    if (TESTNET.wif == w) {
+      return TESTNET;
+    } else if (BITCOIN.wif == w) {
+      return BITCOIN;
+    }
+    throw ArgumentError("wif perefix $wif not supported, only bitcoin or testnet accepted");
   }
-}
 
-class Bip32Type {
-  int public;
-  int private;
+  static AddressType? networkFromXPrivePrefix(Uint8List prefix) {
+    final w = "0x${bytesToHex(prefix)}";
+    if (TESTNET.extendPrivate.values.contains(w)) {
+      return TESTNET.extendPrivate.keys
+          .firstWhere((element) => TESTNET.extendPrivate[element] == w);
+    } else if (BITCOIN.extendPrivate.values.contains(w)) {
+      return BITCOIN.extendPrivate.keys
+          .firstWhere((element) => BITCOIN.extendPrivate[element] == w);
+    }
+    return null;
+  }
 
-  Bip32Type({required this.public, required this.private});
+  static AddressType? networkFromXPublicPrefix(Uint8List prefix) {
+    final w = "0x${bytesToHex(prefix)}";
+    if (TESTNET.extendPublic.values.contains(w)) {
+      return TESTNET.extendPublic.keys.firstWhere((element) => TESTNET.extendPublic[element] == w);
+    } else if (BITCOIN.extendPublic.values.contains(w)) {
+      return BITCOIN.extendPublic.keys.firstWhere((element) => BITCOIN.extendPublic[element] == w);
+    }
+    return null;
+  }
 
   @override
   String toString() {
-    return 'Bip32Type{public: $public, private: $private}';
+    return 'NetworkType{messagePrefix: $messagePrefix, bech32: $bech32, bip32: ${bip32.toString()}, pubKeyHash: $pubKeyHash, scriptHash: $scriptHash, wif: $wif}';
   }
 }
 
-final bitcoin = new NetworkType(
-    messagePrefix: '\x18Bitcoin Signed Message:\n',
-    bech32: 'bc',
-    bip32: new Bip32Type(public: 0x0488b21e, private: 0x0488ade4),
-    pubKeyHash: 0x00,
-    scriptHash: 0x05,
-    wif: 0x80);
-
-final testnet = new NetworkType(
-    messagePrefix: '\x18Bitcoin Signed Message:\n',
-    bech32: 'tb',
-    bip32: new Bip32Type(public: 0x043587cf, private: 0x04358394),
-    pubKeyHash: 0x6f,
-    scriptHash: 0xc4,
-    wif: 0xef);
+final bitcoin = NetworkType.BITCOIN;
+final testnet = NetworkType.TESTNET;
+
+final litecoin = NetworkType(
+  messagePrefix: '\x19Litecoin Signed Message:\n',
+  bech32: 'ltc',
+  bip32: Bip32Type(public: 0x0488b21e, private: 0x0488ade4),
+  pubKeyHash: 0x30,
+  scriptHash: 0x32,
+  wif: 0xb0,
+  p2pkhPrefix: 0x30,
+  network: bitcoin.network,
+  p2shPrefix: 0x32,
+  extendPublic: bitcoin.extendPublic,
+  extendPrivate: bitcoin.extendPrivate,
+);
diff --git a/lib/src/payments/address/address.dart b/lib/src/payments/address/address.dart
new file mode 100644
index 0000000..0c48552
--- /dev/null
+++ b/lib/src/payments/address/address.dart
@@ -0,0 +1,250 @@
+import 'dart:typed_data';
+
+import 'core.dart';
+import 'package:bitcoin_flutter/src/payments/script/script.dart';
+import '../tools/tools.dart';
+import '../constants/constants.dart';
+import 'package:bitcoin_flutter/src/models/networks.dart';
+import '../../utils/string.dart';
+import '../../utils/uint8list.dart';
+import '../../utils/constants/op.dart';
+import 'package:bs58check/bs58check.dart' as bs58check;
+import 'package:bitcoin_flutter/src/utils/script.dart' as bscript;
+
+abstract class BipAddress implements BitcoinAddress {
+  /// Represents a Bitcoin address
+  ///
+  /// [hash160] the hash160 string representation of the address; hash160 represents
+  /// two consequtive hashes of the public key or the redeem script, first
+  /// a SHA-256 and then an RIPEMD-160
+  BipAddress({
+    String? address,
+    String? pubkey,
+    String? signature,
+    String? hash160,
+    Script? scriptPubKey,
+    Script? scriptSig,
+    NetworkType? networkType,
+  }) {
+    this._networkType = networkType ?? NetworkType.BITCOIN;
+
+    if (scriptSig != null) {
+      _decodeScriptSig(scriptSig);
+    } else {
+      if (pubkey != null) {
+        _pubkey = pubkey;
+      }
+      if (signature != null) {
+        _signature = signature;
+      }
+    }
+
+    if (_pubkey != null) {
+      final bytes = _pubkey!.hexToBytes;
+      if (!bytes.isPoint) {
+        throw ArgumentError("Input has invalid pubkey");
+      }
+      _h160 = _pubkey!.hexToBytes.ripemd160Hash.hex;
+    } else if (hash160 != null) {
+      if (!isValidHash160(hash160)) {
+        throw Exception("Invalid value for parameter hash160.");
+      }
+      _h160 = hash160;
+    } else if (address != null) {
+      if (!isValidAddress(address, type, network: this.networkType))
+        throw ArgumentError("Invalid address");
+
+      _h160 = _addressToHash160(address);
+    } else if (scriptPubKey != null) {
+      _h160 = _scriptToHash160(scriptPubKey);
+    } else {
+      if (type == AddressType.p2pk) return;
+      throw ArgumentError("Not enough data");
+    }
+  }
+
+  String? _pubkey;
+  String? _signature;
+  late final String _h160;
+  late final NetworkType _networkType;
+
+  String? get pubkey {
+    return _pubkey;
+  }
+
+  String? get signature {
+    return _signature;
+  }
+
+  NetworkType get networkType {
+    return _networkType;
+  }
+
+  String get h160 {
+    if (type == AddressType.p2pk) throw UnimplementedError();
+    return _h160;
+  }
+
+  String _addressToHash160(String address) {
+    final decode = bs58check.decode(address);
+    return decode.sublist(1).hex;
+  }
+
+  String _scriptToHash160(Script s) {
+    throw UnimplementedError();
+  }
+
+  void _decodeScriptSig(Script s) {
+    throw UnimplementedError();
+  }
+
+  /// returns the address's string encoding
+  @override
+  String get address {
+    Uint8List tobytes = _h160.hexToBytes;
+    switch (type) {
+      case AddressType.p2wpkhInP2sh:
+      case AddressType.p2wshInP2sh:
+      case AddressType.p2pkhInP2sh:
+      case AddressType.p2pkInP2sh:
+        tobytes = Uint8List.fromList([networkType.p2shPrefix, ...tobytes]);
+        break;
+      case const (AddressType.p2pkh) || const (AddressType.p2pk):
+        tobytes = Uint8List.fromList([networkType.p2pkhPrefix, ...tobytes]);
+        break;
+      default:
+    }
+    return bs58check.encode(tobytes);
+  }
+}
+
+class P2shAddress extends BipAddress {
+  P2shAddress({
+    super.address,
+    super.pubkey,
+    super.signature,
+    super.hash160,
+    super.scriptPubKey,
+    super.scriptSig,
+    super.networkType,
+  }) : type = AddressType.p2pkInP2sh;
+
+  static RegExp get REGEX => RegExp(r'(^|\s)[23][a-km-zA-HJ-NP-Z1-9]{25,34}($|\s)');
+
+  @override
+  final AddressType type;
+
+  P2shAddress.fromScript({super.scriptPubKey, this.type = AddressType.p2pkInP2sh})
+      : assert(type == AddressType.p2pkInP2sh ||
+            type == AddressType.p2pkhInP2sh ||
+            type == AddressType.p2wpkhInP2sh ||
+            type == AddressType.p2wshInP2sh);
+
+  @override
+  Script get scriptPubkey {
+    return Script(script: [OP_WORDS.OP_HASH160, _h160, OP_WORDS.OP_EQUAL]);
+  }
+}
+
+class P2pkhAddress extends BipAddress {
+  P2pkhAddress({
+    super.address,
+    super.pubkey,
+    super.signature,
+    super.hash160,
+    super.scriptPubKey,
+    super.scriptSig,
+    super.networkType,
+  });
+
+  static RegExp get REGEX => RegExp(r'(^|\s)[1mn][a-km-zA-HJ-NP-Z1-9]{25,34}($|\s)');
+  static get overheadSizeVB => 10;
+  static get inputSizeVB => 148;
+  static get outputSizeVB => 34;
+
+  @override
+  Script get scriptPubkey {
+    return Script(script: [
+      OP_WORDS.OP_DUP,
+      OP_WORDS.OP_HASH160,
+      _h160,
+      OP_WORDS.OP_EQUALVERIFY,
+      OP_WORDS.OP_CHECKSIG
+    ]);
+  }
+
+  @override
+  AddressType get type => AddressType.p2pkh;
+
+  // https://bitcoin.stackexchange.com/questions/105262/is-a-valid-bitcoin-address-character
+  static bool validPubkeyScript(Uint8List data) {
+    // A P2PKH output script is composed of the following instructions:
+    return data.length == 25 &&
+        // OP_DUP (0x76)
+        data[0] == OPS['OP_DUP'] &&
+        // OP_HASH160 (0xa9)
+        data[1] == OPS['OP_HASH160'] &&
+        // 0x14 (20 in hexadecimal, indicating a 20 byte push)
+        data[2] == 0x14 &&
+        // <pubkey hash> (20 bytes)
+        // ... data[3] to data[22] ...
+        // OP_EQUALVERIFY (0x88)
+        data[23] == OPS['OP_EQUALVERIFY'] &&
+        // OP_CHECKSIG (0xac)
+        data[24] == OPS['OP_CHECKSIG'];
+  }
+
+  @override
+  String _scriptToHash160(Script s) {
+    if (!validPubkeyScript(s.toBytes())) throw new ArgumentError('Output is invalid');
+    final h160 = s.script[2];
+    return h160;
+  }
+
+  static bool validSigScript(List<dynamic>? data) {
+    if (data == null || data.isEmpty) throw new ArgumentError('Input is invalid');
+
+    List<String> chunks =
+        (data is Uint8List) ? Script.fromRaw(byteData: data).script : (data as List<String>);
+
+    if (chunks.length != 2) throw new ArgumentError('Input is invalid');
+
+    if (!bscript.isCanonicalScriptSignature(chunks[0].fromHex))
+      throw new ArgumentError('Input has invalid signature');
+
+    if (!bscript.isCanonicalPubKey(chunks[1].fromHex))
+      throw new ArgumentError('Input has invalid pubkey');
+
+    return true;
+  }
+
+  @override
+  void _decodeScriptSig(Script sigScript) {
+    final chunks = sigScript.script;
+    if (!validSigScript(sigScript.script)) throw new ArgumentError('Input is invalid');
+
+    _pubkey = chunks[1];
+    _signature = chunks[0];
+  }
+
+  Script get sigScript {
+    return Script(script: [_signature, _pubkey]);
+  }
+}
+
+// Deprecated but may be useful for library uses, like identifying old P2PK payments, parsing addresses etc
+class P2pkAddress extends BipAddress {
+  P2pkAddress({required super.pubkey});
+
+  static RegExp get REGEX => RegExp(r'(^|\s)1([A-Za-z0-9]{34})($|\s)');
+
+  late final String publicHex;
+
+  @override
+  Script get scriptPubkey {
+    return Script(script: [publicHex, OP_WORDS.OP_CHECKSIG]);
+  }
+
+  @override
+  AddressType get type => AddressType.p2pk;
+}
diff --git a/lib/src/payments/address/core.dart b/lib/src/payments/address/core.dart
new file mode 100644
index 0000000..4df46db
--- /dev/null
+++ b/lib/src/payments/address/core.dart
@@ -0,0 +1,50 @@
+import 'package:bitcoin_flutter/src/payments/script/script.dart';
+import 'package:bitcoin_flutter/src/models/networks.dart';
+
+enum AddressType {
+  // deprecated address type
+  p2pk,
+
+  p2pkh,
+  p2wpkh,
+  p2tr,
+
+  // made up for silent payments, doesn't actually exist
+  p2sp,
+
+  p2wsh,
+  p2wshInP2sh,
+  p2wpkhInP2sh,
+  p2pkhInP2sh,
+  p2pkInP2sh;
+
+  @override
+  String toString() {
+    String label = '';
+    switch (this) {
+      case AddressType.p2pkh:
+        label = 'Bitcoin Legacy';
+        break;
+      case AddressType.p2wpkh:
+        label = 'Bitcoin SegWit';
+        break;
+      case AddressType.p2tr:
+        label = 'Bitcoin Taproot';
+        break;
+      case AddressType.p2sp:
+        label = 'Bitcoin Silent Payments';
+        break;
+      default:
+        label = 'Mainnet';
+        break;
+    }
+    return label;
+  }
+}
+
+abstract class BitcoinAddress {
+  NetworkType get networkType;
+  AddressType get type;
+  Script get scriptPubkey;
+  String get address;
+}
diff --git a/lib/src/payments/address/segwit_address.dart b/lib/src/payments/address/segwit_address.dart
new file mode 100644
index 0000000..1247229
--- /dev/null
+++ b/lib/src/payments/address/segwit_address.dart
@@ -0,0 +1,165 @@
+import '../../crypto.dart';
+import '../../formatting/bytes_num_formatting.dart';
+
+import 'package:bitcoin_flutter/src/models/networks.dart';
+import 'core.dart';
+import '../constants/constants.dart';
+import 'package:bitcoin_flutter/src/payments/script/script.dart';
+import '../../utils/string.dart';
+import '../../utils/uint8list.dart';
+import '../../ec/ec_public.dart';
+import 'package:bech32/bech32.dart';
+
+abstract class SegwitAddress implements BitcoinAddress {
+  /// Represents a Bitcoin segwit address
+  ///
+  /// [program] for segwit v0 this is the hash string representation of either the address;
+  /// it can be either a public key hash (P2WPKH) or the hash of the script (P2WSH)
+  /// for segwit v1 (aka taproot) this is the public key
+  SegwitAddress(
+      {String? address,
+      String? program,
+      Script? script,
+      String? pubkey,
+      NetworkType? networkType,
+      this.version = P2WPKH_ADDRESS_V0}) {
+    this._networkType = networkType ?? NetworkType.BITCOIN;
+
+    if (version == P2WPKH_ADDRESS_V0 || version == P2WSH_ADDRESS_V0) {
+      segwitNumVersion = 0;
+    } else if (version == P2TR_ADDRESS_V1) {
+      segwitNumVersion = 1;
+    } else {
+      throw ArgumentError('A valid segwit version is required.');
+    }
+    if (program != null) {
+      _program = program;
+    } else if (address != null) {
+      _program = _addressToHash(address);
+    } else if (script != null) {
+      _program = _scriptToHash(script);
+    } else if (pubkey != null) {
+      _program = hash160(pubkey.fromHex).hex;
+    }
+  }
+
+  late final String _program;
+
+  String get getProgram => _program;
+
+  final String version;
+  late final int segwitNumVersion;
+  late final NetworkType _networkType;
+
+  NetworkType get networkType {
+    return _networkType;
+  }
+
+  String _addressToHash(String address) {
+    Segwit? convert;
+    try {
+      convert = segwit.decode(address, isBech32m: this.version == P2TR_ADDRESS_V1);
+    } catch (_) {}
+    if (convert == null) {
+      throw ArgumentError("Invalid value for parameter address.");
+    }
+
+    if (networkType.bech32 != convert.hrp)
+      throw new ArgumentError('Invalid prefix or Network mismatch');
+
+    if (convert.version != segwitNumVersion) {
+      throw ArgumentError("Invalid segwit version.");
+    }
+    return bytesToHex(convert.program);
+  }
+
+  /// returns the address's string encoding (Bech32)
+  @override
+  String get address {
+    final bytes = hexToBytes(_program);
+    String? sw;
+    try {
+      sw = segwit.encode(Segwit(networkType.bech32, segwitNumVersion, bytes));
+    } catch (_) {}
+    if (sw == null) {
+      throw ArgumentError("invalid address");
+    }
+
+    return sw;
+  }
+
+  String _scriptToHash(Script script) {
+    final toBytes = script.toBytes();
+    final toHash = singleHash(toBytes);
+    return bytesToHex(toHash);
+  }
+}
+
+class P2wpkhAddress extends SegwitAddress {
+  static RegExp get REGEX => RegExp(r'(^|\s)(bc|tb)1q[ac-hj-np-z02-9]{25,39}($|\s)');
+
+  /// Encapsulates a P2WPKH address.
+  P2wpkhAddress({super.address, super.program, super.pubkey, super.networkType})
+      : super(version: P2WPKH_ADDRESS_V0);
+
+  /// returns the scriptPubKey of a P2WPKH witness script
+  @override
+  Script get scriptPubkey {
+    return Script(script: ['OP_0', _program]);
+  }
+
+  /// returns the type of address
+  @override
+  AddressType get type => AddressType.p2wpkh;
+}
+
+class P2trAddress extends SegwitAddress {
+  static RegExp get REGEX =>
+      RegExp(r'(^|\s)(bc)|(tb)1p([ac-hj-np-z02-9]{39}|[ac-hj-np-z02-9]{59})|1p[ac-hj-np-z02-9]{8,89}($|\s)');
+
+  /// Encapsulates a P2TR (Taproot) address.
+  P2trAddress({String? program, super.address, String? pubkey, super.networkType})
+      : super(
+            version: P2TR_ADDRESS_V1,
+            program: program ?? (pubkey != null ? ECPublic.fromHex(pubkey).toTapPoint() : null));
+
+  /// returns the address's string encoding (Bech32m different from Bech32)
+  @override
+  String get address {
+    final bytes = hexToBytes(_program);
+    String? sw;
+    try {
+      sw = segwit.encode(Segwit(networkType.bech32, segwitNumVersion, bytes), isBech32m: true);
+    } catch (_) {}
+    if (sw == null) {
+      throw ArgumentError("invalid address");
+    }
+
+    return sw;
+  }
+
+  /// returns the scriptPubKey of a P2TR witness script
+  @override
+  Script get scriptPubkey {
+    return Script(script: ['OP_1', _program]);
+  }
+
+  /// returns the type of address
+  @override
+  AddressType get type => AddressType.p2tr;
+}
+
+class P2wshAddress extends SegwitAddress {
+  /// Encapsulates a P2WSH address.
+  P2wshAddress({super.script, super.address}) : super(version: P2WSH_ADDRESS_V0);
+
+  /// Returns the scriptPubKey of a P2WPKH witness script
+  @override
+  Script get scriptPubkey {
+    return Script(script: ['OP_0', _program]);
+  }
+
+  /// Returns the type of address
+  @override
+  AddressType get type => AddressType.p2wsh;
+}
diff --git a/lib/src/payments/bitcoin/input.dart b/lib/src/payments/bitcoin/input.dart
new file mode 100644
index 0000000..a248e4f
--- /dev/null
+++ b/lib/src/payments/bitcoin/input.dart
@@ -0,0 +1,137 @@
+import 'dart:typed_data';
+
+import 'package:bitcoin_flutter/src/payments/script/script.dart';
+import 'package:bitcoin_flutter/src/payments/constants/constants.dart';
+import 'package:bitcoin_flutter/src/utils/string.dart';
+import 'package:bitcoin_flutter/src/utils/check_types.dart';
+import 'package:bitcoin_flutter/src/formatting/bytes_num_formatting.dart';
+
+/// A transaction input requires a transaction id of a UTXO and the index of that UTXO.
+///
+/// [txId] the transaction id as a hex string
+/// [txIndex] the index of the UTXO that we want to spend
+/// [scriptSig] the script that satisfies the locking conditions
+/// [sequence] the input sequence (for timelocks, RBF, etc.)
+class TxInput {
+  TxInput({required this.txId, required this.txIndex, Script? scriptSig, Uint8List? sequence})
+      : sequence = sequence ?? Uint8List.fromList(DEFAULT_TX_SEQUENCE),
+        scriptSig = scriptSig ?? Script(script: []) {
+    if (!isHash256bit(txId.fromHex)) throw new ArgumentError('Invalid input hash');
+    if (!isUint(txIndex, 32)) throw new ArgumentError('Invalid input index');
+  }
+
+  final String txId;
+  final int txIndex;
+  Script scriptSig;
+  Uint8List sequence;
+
+  TxInput copy() {
+    return TxInput(txId: txId, txIndex: txIndex, scriptSig: scriptSig, sequence: sequence);
+  }
+
+  @override
+  String toString() {
+    return 'TxInput{txId: $txId, txIndex: $txIndex, scriptSig: $scriptSig, sequence: $sequence}';
+  }
+
+  /// serializes TxInput to bytes
+  Uint8List toBytes() {
+    final txidBytes = Uint16List.fromList(txId.fromHex.reversed.toList());
+
+    final txoutBytes = Uint8List(4);
+    ByteData.view(txoutBytes.buffer).setUint32(0, txIndex, Endian.little);
+
+    final scriptSigBytes = scriptSig.toBytes();
+
+    final scriptSigLengthVarint = encodeVarint(scriptSigBytes.length);
+    final data = Uint8List.fromList([
+      ...txidBytes,
+      ...txoutBytes,
+      ...scriptSigLengthVarint,
+      ...scriptSigBytes,
+      ...sequence,
+    ]);
+    return data;
+  }
+
+  static (TxInput, int) fromRaw({required String raw, int cursor = 0, bool hasSegwit = false}) {
+    final txInputRaw = hexToBytes(raw);
+    Uint8List inpHash =
+        Uint8List.fromList(txInputRaw.sublist(cursor, cursor + 32).reversed.toList());
+    if (inpHash.isEmpty) {
+      throw ArgumentError("Input transaction hash not found. Probably malformed raw transaction");
+    }
+    Uint8List outputN =
+        Uint8List.fromList(txInputRaw.sublist(cursor + 32, cursor + 36).reversed.toList());
+    cursor += 36;
+    final vi = viToInt(txInputRaw.sublist(cursor, cursor + 9));
+    cursor += vi.$2;
+    Uint8List unlockingScript = txInputRaw.sublist(cursor, cursor + vi.$1);
+    cursor += vi.$1;
+    Uint8List sequenceNumberData = txInputRaw.sublist(cursor, cursor + 4);
+    cursor += 4;
+    return (
+      TxInput(
+        txId: bytesToHex(inpHash),
+        txIndex: int.parse(bytesToHex(outputN), radix: 16),
+        scriptSig: Script.fromRaw(hexData: bytesToHex(unlockingScript), hasSegwit: hasSegwit),
+        sequence: sequenceNumberData,
+      ),
+      cursor
+    );
+  }
+}
+
+/// Used to provide the sequence to transaction inputs and to scripts.
+///
+/// [value] The value of the block height or the 512 seconds increments
+/// [seqType] Specifies the type of sequence (TYPE_RELATIVE_TIMELOCK | TYPE_ABSOLUTE_TIMELOCK | TYPE_REPLACE_BY_FEE
+/// [isTypeBlock] If type is TYPE_RELATIVE_TIMELOCK then this specifies its type (block height or 512 secs increments)
+class Sequence {
+  Sequence({required this.seqType, required this.value, this.isTypeBlock = true}) {
+    if (seqType == TYPE_RELATIVE_TIMELOCK && (value < 1 || value > 0xffff)) {
+      throw ArgumentError('Sequence should be between 1 and 65535');
+    }
+  }
+  final int seqType;
+  final int value;
+  final bool isTypeBlock;
+
+  /// Serializes the relative sequence as required in a transaction
+  Uint8List forInputSequence() {
+    if (seqType == TYPE_ABSOLUTE_TIMELOCK) {
+      return Uint8List.fromList(ABSOLUTE_TIMELOCK_SEQUENCE);
+    }
+
+    if (seqType == TYPE_REPLACE_BY_FEE) {
+      return Uint8List.fromList(REPLACE_BY_FEE_SEQUENCE);
+    }
+    if (seqType == TYPE_RELATIVE_TIMELOCK) {
+      int seq = 0;
+      if (!isTypeBlock) {
+        seq |= 1 << 22;
+      }
+      seq |= value;
+      return Uint8List.fromList([
+        seq & 0xFF,
+        (seq >> 8) & 0xFF,
+        (seq >> 16) & 0xFF,
+        (seq >> 24) & 0xFF,
+      ]);
+    }
+
+    throw ArgumentError("Invalid seqType");
+  }
+
+  /// Returns the appropriate integer for a script; e.g. for relative timelocks
+  int forScript() {
+    if (seqType == TYPE_REPLACE_BY_FEE) {
+      throw const FormatException("RBF is not to be included in a script.");
+    }
+    int scriptIntiger = value;
+    if (seqType == TYPE_RELATIVE_TIMELOCK && !isTypeBlock) {
+      scriptIntiger |= 1 << 22;
+    }
+    return scriptIntiger;
+  }
+}
diff --git a/lib/src/payments/bitcoin/multisig_script.dart b/lib/src/payments/bitcoin/multisig_script.dart
new file mode 100644
index 0000000..7813111
--- /dev/null
+++ b/lib/src/payments/bitcoin/multisig_script.dart
@@ -0,0 +1,120 @@
+import 'package:bitcoin_flutter/src/payments/address/core.dart';
+import 'package:bitcoin_flutter/src/payments/address/address.dart';
+import 'package:bitcoin_flutter/src/payments/address/segwit_address.dart';
+import 'package:bitcoin_flutter/src/payments/script/script.dart';
+import 'package:bitcoin_flutter/src/ec/ec_public.dart';
+
+/// MultiSignatureSigner is an interface that defines methods required for representing
+/// signers in a multi-signature scheme. A multi-signature signer typically includes
+/// information about their public key and weight within the scheme.
+class MultiSignatureSigner {
+  MultiSignatureSigner._(this.publicKey, this.weight);
+
+  /// PublicKey returns the public key associated with the signer.
+  final String publicKey;
+
+  /// Weight returns the weight or significance of the signer within the multi-signature scheme.
+  /// The weight is used to determine the number of signatures required for a valid transaction.
+  final int weight;
+
+  /// creates a new instance of a multi-signature signer with the
+  /// specified public key and weight.
+  factory MultiSignatureSigner({required String publicKey, required int weight}) {
+    ECPublic.fromHex(publicKey);
+    return MultiSignatureSigner._(publicKey, weight);
+  }
+}
+
+/// MultiSignatureAddress represents a multi-signature Bitcoin address configuration, including
+/// information about the required signers, threshold, the address itself,
+/// and the script details used for multi-signature transactions.
+class MultiSignatureAddress {
+  /// Signers is a collection of signers participating in the multi-signature scheme.
+  final List<MultiSignatureSigner> signers;
+
+  /// Threshold is the minimum number of signatures required to spend the bitcoins associated
+  /// with this address.
+  final int threshold;
+
+  /// Address represents the Bitcoin address associated with this multi-signature configuration.
+  final BitcoinAddress address;
+
+  /// ScriptDetails provides details about the multi-signature script used in transactions,
+  /// including "OP_M", compressed public keys, "OP_N", and "OP_CHECKMULTISIG."
+  final String scriptDetails;
+
+  MultiSignatureAddress._({
+    required this.signers,
+    required this.threshold,
+    required this.address,
+    required this.scriptDetails,
+  });
+
+  /// CreateMultiSignatureAddress creates a new instance of a MultiSignatureAddress, representing
+  /// a multi-signature Bitcoin address configuration. It allows you to specify the minimum number
+  /// of required signatures (threshold), provide the collection of signers participating in the
+  /// multi-signature scheme, and specify the address type.
+  factory MultiSignatureAddress({
+    required int threshold,
+    required List<MultiSignatureSigner> signers,
+    required AddressType addressType,
+  }) {
+    final sumWeight = signers.fold(0, (sum, signer) => sum + signer.weight);
+    if (threshold > 16 || threshold < 1) {
+      throw Exception('The threshold should be between 1 and 16');
+    }
+    if (sumWeight > 16) {
+      throw Exception('The total weight of the owners should not exceed 16');
+    }
+    if (sumWeight < threshold) {
+      throw Exception('The total weight of the signatories should reach the threshold');
+    }
+    final multiSigScript = <Object>['OP_$threshold'];
+    for (final signer in signers) {
+      for (var w = 0; w < signer.weight; w++) {
+        multiSigScript.add(signer.publicKey);
+      }
+    }
+    multiSigScript.addAll(['OP_$sumWeight', 'OP_CHECKMULTISIG']);
+    final script = Script(script: multiSigScript);
+    final p2wsh = P2wshAddress(script: script);
+    switch (addressType) {
+      case AddressType.p2wsh:
+        {
+          return MultiSignatureAddress._(
+            signers: signers,
+            threshold: threshold,
+            address: p2wsh,
+            scriptDetails: script.toHex(),
+          );
+        }
+      case AddressType.p2wshInP2sh:
+        {
+          final addr = P2shAddress.fromScript(
+              scriptPubKey: p2wsh.scriptPubkey, type: AddressType.p2wshInP2sh);
+          return MultiSignatureAddress._(
+            signers: signers,
+            threshold: threshold,
+            address: addr,
+            scriptDetails: script.toHex(),
+          );
+        }
+      default:
+        {
+          throw Exception('addressType should be P2WSH or P2WSHInP2SH');
+        }
+    }
+  }
+
+  List<String> showScript() {
+    final sumWeight = signers.fold(0, (sum, signer) => sum + signer.weight);
+    final multiSigScript = <String>['OP_$threshold'];
+    for (final signer in signers) {
+      for (var w = 0; w < signer.weight; w++) {
+        multiSigScript.add(signer.publicKey);
+      }
+    }
+    multiSigScript.addAll(['OP_$sumWeight', 'OP_CHECKMULTISIG']);
+    return multiSigScript;
+  }
+}
diff --git a/lib/src/payments/bitcoin/output.dart b/lib/src/payments/bitcoin/output.dart
new file mode 100644
index 0000000..cb41c32
--- /dev/null
+++ b/lib/src/payments/bitcoin/output.dart
@@ -0,0 +1,51 @@
+import 'dart:typed_data';
+import 'package:bitcoin_flutter/src/payments/script/script.dart';
+import 'package:bitcoin_flutter/src/formatting/bytes_num_formatting.dart';
+
+/// Represents a transaction output.
+///
+/// [amount] the value we want to send to this output in satoshis
+/// [scriptPubKey] the script that will lock this amount
+class TxOutput {
+  TxOutput({required this.amount, required this.scriptPubKey});
+
+  final BigInt amount;
+  final Script scriptPubKey;
+
+  ///  creates a copy of the object
+  TxOutput copy() {
+    return TxOutput(amount: amount, scriptPubKey: scriptPubKey);
+  }
+
+  /// serializes TxInput to bytes
+  Uint8List toBytes() {
+    final amountBytes = packBigIntToLittleEndian(amount);
+    Uint8List scriptBytes = scriptPubKey.toBytes();
+    final data =
+        Uint8List.fromList([...amountBytes, ...encodeVarint(scriptBytes.length), ...scriptBytes]);
+    return data;
+  }
+
+  static (TxOutput, int) fromRaw(
+      {required String raw, required int cursor, bool hasSegwit = false}) {
+    final txoutputraw = hexToBytes(raw);
+    int value = ByteData.sublistView(txoutputraw, cursor, cursor + 8).getInt64(0, Endian.little);
+    cursor += 8;
+
+    final vi = viToInt(txoutputraw.sublist(cursor, cursor + 9));
+    cursor += vi.$2;
+    Uint8List lockScript = txoutputraw.sublist(cursor, cursor + vi.$1);
+    cursor += vi.$1;
+    return (
+      TxOutput(
+          amount: BigInt.from(value),
+          scriptPubKey: Script.fromRaw(hexData: bytesToHex(lockScript), hasSegwit: hasSegwit)),
+      cursor
+    );
+  }
+
+  @override
+  String toString() {
+    return 'Output{scriptPubKey: $scriptPubKey, amount: $amount}';
+  }
+}
diff --git a/lib/src/payments/bitcoin/transaction.dart b/lib/src/payments/bitcoin/transaction.dart
new file mode 100644
index 0000000..ef733db
--- /dev/null
+++ b/lib/src/payments/bitcoin/transaction.dart
@@ -0,0 +1,443 @@
+import 'dart:typed_data';
+import 'package:bitcoin_flutter/src/formatting/bytes_tracker.dart';
+import 'package:bitcoin_flutter/src/payments/script/script.dart';
+import 'package:bitcoin_flutter/src/payments/bitcoin/input.dart';
+import 'package:bitcoin_flutter/src/payments/bitcoin/output.dart';
+import 'package:bitcoin_flutter/src/payments/bitcoin/witness.dart';
+import 'package:bitcoin_flutter/src/payments/constants/constants.dart';
+import 'package:bitcoin_flutter/src/formatting/bytes_num_formatting.dart';
+import 'package:bitcoin_flutter/src/crypto.dart';
+
+/// Represents a Bitcoin transaction
+///
+/// [inputs] A list of all the transaction inputs
+/// [outputs] A list of all the transaction outputs
+/// [locktime] The transaction's locktime parameter
+/// [version] The transaction version
+/// [hasSegwit] Specifies a tx that includes segwit inputs
+/// [witnesses] The witness structure that corresponds to the inputs
+class BtcTransaction {
+  BtcTransaction({
+    required this.inputs,
+    required this.outputs,
+    List<TxWitnessInput> w = const [],
+    this.hasSegwit = false,
+    Uint8List? lock,
+    Uint8List? v,
+    bool? hasTaproot,
+  })  : locktime = lock ?? Uint8List.fromList(DEFAULT_TX_LOCKTIME),
+        version = hasTaproot == true
+            ? Uint8List.fromList(TX_VERSION_2)
+            : (v ?? Uint8List.fromList(DEFAULT_TX_VERSION)) {
+    witnesses.addAll(w);
+  }
+  final List<TxInput> inputs;
+  final List<TxOutput> outputs;
+  final Uint8List locktime;
+  late final Uint8List version;
+  final bool hasSegwit;
+  final List<TxWitnessInput> witnesses = [];
+
+  /// creates a copy of the object (classmethod)
+  static BtcTransaction copy(BtcTransaction tx) {
+    return BtcTransaction(
+        hasSegwit: tx.hasSegwit,
+        inputs: tx.inputs.map((e) => e.copy()).toList(),
+        outputs: tx.outputs.map((e) => e.copy()).toList(),
+        w: tx.witnesses.map((e) => e.copy()).toList(),
+        lock: tx.locktime,
+        v: tx.version);
+  }
+
+  /// Instantiates a Transaction from serialized raw hexadacimal data (classmethod)
+  static BtcTransaction fromRaw(String raw) {
+    final rawtx = hexToBytes(raw);
+    int cursor = 4;
+    Uint8List? flag;
+    bool hasSegwit = false;
+    if (rawtx[4] == 0) {
+      flag = Uint8List.fromList(rawtx.sublist(5, 6));
+      if (flag[0] == 1) {
+        hasSegwit = true;
+      }
+      cursor += 2;
+    }
+    final vi = viToInt(rawtx.sublist(cursor, cursor + 9));
+    cursor += vi.$2;
+
+    List<TxInput> inputs = [];
+    for (int index = 0; index < vi.$1; index++) {
+      final inp = TxInput.fromRaw(raw: raw, hasSegwit: hasSegwit, cursor: cursor);
+
+      inputs.add(inp.$1);
+      cursor = inp.$2;
+    }
+
+    List<TxOutput> outputs = [];
+    final viOut = viToInt(rawtx.sublist(cursor, cursor + 9));
+    cursor += viOut.$2;
+    for (int index = 0; index < viOut.$1; index++) {
+      final inp = TxOutput.fromRaw(raw: raw, hasSegwit: hasSegwit, cursor: cursor);
+      outputs.add(inp.$1);
+      cursor = inp.$2;
+    }
+    List<TxWitnessInput> witnesses = [];
+    if (hasSegwit) {
+      for (int n = 0; n < inputs.length; n++) {
+        final wVi = viToInt(rawtx.sublist(cursor, cursor + 9));
+        cursor += wVi.$2;
+        List<String> witnessesTmp = [];
+        for (int n = 0; n < wVi.$1; n++) {
+          Uint8List witness = Uint8List(0);
+          final wtVi = viToInt(rawtx.sublist(cursor, cursor + 9));
+          if (wtVi.$1 != 0) {
+            witness = rawtx.sublist(cursor + wtVi.$2, cursor + wtVi.$1 + wtVi.$2);
+          }
+          cursor += wtVi.$1 + wtVi.$2;
+          witnessesTmp.add(bytesToHex(witness));
+        }
+
+        witnesses.add(TxWitnessInput(stack: witnessesTmp));
+      }
+    }
+    return BtcTransaction(inputs: inputs, outputs: outputs, w: witnesses, hasSegwit: hasSegwit);
+  }
+
+  /// returns the transaction input's digest that is to be signed according.
+  ///
+  /// [txInIndex] The index of the input that we wish to sign
+  /// [script] The scriptPubKey of the UTXO that we want to spend
+  /// [sighash] The type of the signature hash to be created
+  Uint8List getTransactionDigest(
+      {required int txInIndex, required Script script, int sighash = SIGHASH_ALL}) {
+    final tx = copy(this);
+    for (final i in tx.inputs) {
+      i.scriptSig = Script(script: []);
+    }
+    tx.inputs[txInIndex].scriptSig = script;
+    if ((sighash & 0x1f) == SIGHASH_NONE) {
+      tx.outputs.clear();
+      for (int i = 0; i < tx.inputs.length; i++) {
+        if (i != txInIndex) {
+          tx.inputs[i].sequence = Uint8List.fromList(EMPTY_TX_SEQUENCE);
+        }
+      }
+    } else if ((sighash & 0x1f) == SIGHASH_SINGLE) {
+      if (txInIndex >= tx.outputs.length) {
+        throw ArgumentError("Transaction index is greater than theavailable outputs");
+      }
+      final txout = tx.outputs[txInIndex];
+      tx.outputs.clear();
+      for (int i = 0; i < txInIndex; i++) {
+        tx.outputs
+            .add(TxOutput(amount: BigInt.from(NEGATIVE_SATOSHI), scriptPubKey: Script(script: [])));
+      }
+      tx.outputs.add(txout);
+      for (int i = 0; i < tx.inputs.length; i++) {
+        if (i != txInIndex) {
+          tx.inputs[i].sequence = Uint8List.fromList(EMPTY_TX_SEQUENCE);
+        }
+      }
+    }
+    if ((sighash & SIGHASH_ANYONECANPAY) != 0) {
+      final inp = tx.inputs[txInIndex];
+      tx.inputs.clear();
+      tx.inputs.add(inp);
+    }
+    Uint8List txForSign = tx.toBytes(segwit: false);
+
+    Uint8List packedData = packInt32LE(sighash);
+
+    txForSign = Uint8List.fromList([...txForSign, ...packedData]);
+    return doubleHash(txForSign);
+  }
+
+  /// Serializes Transaction to bytes
+  Uint8List toBytes({bool segwit = false}) {
+    DynamicByteTracker data = DynamicByteTracker();
+    try {
+      data.add(version);
+      if (segwit) {
+        data.add([0x00, 0x01]);
+      }
+      final txInCountBytes = encodeVarint(inputs.length);
+      final txOutCountBytes = encodeVarint(outputs.length);
+
+      data.add(txInCountBytes);
+      for (final txIn in inputs) {
+        data.add(txIn.toBytes());
+      }
+      data.add(txOutCountBytes);
+      for (final txOut in outputs) {
+        data.add(txOut.toBytes());
+      }
+      if (segwit) {
+        for (final wit in witnesses) {
+          final witnessesCountBytes = Uint8List.fromList([wit.stack.length]);
+          data.add(witnessesCountBytes);
+          data.add(wit.toBytes());
+        }
+      }
+      data.add(locktime);
+      return data.toBytes();
+    } finally {
+      data.close();
+    }
+  }
+
+  /// returns the transaction input's segwit digest that is to be signed according to sighash.
+  ///
+  /// [txInIndex] The index of the input that we wish to sign.
+  /// [script] The scriptCode (template) that corresponds to the segwit, transaction output type that we want to spend.
+  /// [amount] The amount of the UTXO to spend is included in the signature for segwit (in satoshis).
+  /// [sighash] The type of the signature hash to be created.
+  Uint8List getTransactionSegwitDigit(
+      {required int txInIndex,
+      required Script script,
+      int sighash = SIGHASH_ALL,
+      required BigInt amount}) {
+    final tx = copy(this);
+    Uint8List hashPrevouts = Uint8List(32);
+    Uint8List hashSequence = Uint8List(32);
+    Uint8List hashOutputs = Uint8List(32);
+    int basicSigHashType = sighash & 0x1F;
+    bool anyoneCanPay = (sighash & 0xF0) == SIGHASH_ANYONECANPAY;
+    bool signAll = (basicSigHashType != SIGHASH_SINGLE) && (basicSigHashType != SIGHASH_NONE);
+    if (!anyoneCanPay) {
+      hashPrevouts = Uint8List(0);
+      for (final txin in tx.inputs) {
+        Uint8List txidBytes = Uint8List.fromList(hexToBytes(txin.txId).reversed.toList());
+        Uint8List txoutIndexBytes = packUint32LE(txin.txIndex);
+
+        hashPrevouts = Uint8List.fromList([...hashPrevouts, ...txidBytes, ...txoutIndexBytes]);
+      }
+      hashPrevouts = doubleHash(hashPrevouts);
+    }
+
+    if (!anyoneCanPay && signAll) {
+      hashSequence = Uint8List(0);
+      for (final i in tx.inputs) {
+        hashSequence = Uint8List.fromList([...hashSequence, ...i.sequence]);
+      }
+      hashSequence = doubleHash(hashSequence);
+    }
+    if (signAll) {
+      hashOutputs = Uint8List(0);
+      for (final i in tx.outputs) {
+        Uint8List amountBytes = packBigIntToLittleEndian(i.amount);
+        Uint8List scriptBytes = i.scriptPubKey.toBytes();
+        hashOutputs = Uint8List.fromList(
+            [...hashOutputs, ...amountBytes, scriptBytes.length, ...scriptBytes]);
+      }
+      hashOutputs = doubleHash(hashOutputs);
+    } else if (basicSigHashType == SIGHASH_SINGLE && txInIndex < tx.outputs.length) {
+      final out = tx.outputs[txInIndex];
+      Uint8List packedAmount = packBigIntToLittleEndian(out.amount);
+      final scriptBytes = out.scriptPubKey.toBytes();
+      Uint8List lenScriptBytes = Uint8List.fromList([scriptBytes.length]);
+      hashOutputs = Uint8List.fromList([...packedAmount, ...lenScriptBytes, ...scriptBytes]);
+      hashOutputs = doubleHash(hashOutputs);
+    }
+
+    DynamicByteTracker txForSigning = DynamicByteTracker();
+    txForSigning.add(version);
+    txForSigning.add(hashPrevouts);
+    txForSigning.add(hashSequence);
+    final txIn = inputs[txInIndex];
+
+    Uint8List txidBytes = Uint8List.fromList(hexToBytes(txIn.txId).reversed.toList());
+    Uint8List txoutIndexBytes = packUint32LE(txIn.txIndex);
+    txForSigning.add(Uint8List.fromList([...txidBytes, ...txoutIndexBytes]));
+    txForSigning.add(Uint8List.fromList([script.toBytes().length]));
+    txForSigning.add(script.toBytes());
+    Uint8List packedAmount = packBigIntToLittleEndian(amount);
+    txForSigning.add(packedAmount);
+    txForSigning.add(txIn.sequence);
+    txForSigning.add(hashOutputs);
+    txForSigning.add(locktime);
+    Uint8List packedSighash = packInt32LE(sighash);
+    txForSigning.add(packedSighash);
+    txForSigning.close();
+    return doubleHash(txForSigning.toBytes());
+  }
+
+  /// Returns the segwit v1 (taproot) transaction's digest for signing.
+  ///
+  /// [txIndex] The index of the input that we wish to sign
+  /// [scriptPubKeys] he scriptPubkeys that correspond to all the inputs/UTXOs
+  /// [amounts] The amounts that correspond to all the inputs/UTXOs
+  /// [extFlags] Extension mechanism, default is 0; 1 is for script spending (BIP342)
+  /// [script] The script that we are spending (ext_flag=1)
+  /// [leafVar] The script version, LEAF_VERSION_TAPSCRIPT for the default tapscript
+  /// [sighash] The type of the signature hash to be created
+  Uint8List getTransactionTaprootDigset(
+      {required int txIndex,
+      required List<Script> scriptPubKeys,
+      required List<BigInt> amounts,
+      int extFlags = 0,
+      Script? script,
+      int leafVar = LEAF_VERSION_TAPSCRIPT,
+      int sighash = TAPROOT_SIGHASH_ALL}) {
+    script ??= Script(script: []);
+    final newTx = copy(this);
+    bool sighashNone = (sighash & 0x03) == SIGHASH_NONE;
+    bool sighashSingle = (sighash & 0x03) == SIGHASH_SINGLE;
+    bool anyoneCanPay = (sighash & 0x80) == SIGHASH_ANYONECANPAY;
+    DynamicByteTracker txForSign = DynamicByteTracker();
+    txForSign.add([0]);
+    txForSign.add(Uint16List.fromList([sighash]));
+    txForSign.add(version);
+    txForSign.add(locktime);
+    Uint8List hashPrevouts = Uint8List(0);
+    Uint8List hashAmounts = Uint8List(0);
+    Uint8List hashScriptPubkeys = Uint8List(0);
+    Uint8List hashSequences = Uint8List(0);
+    Uint8List hashOutputs = Uint8List(0);
+    if (!anyoneCanPay) {
+      for (final txin in newTx.inputs) {
+        Uint8List txidBytes = Uint8List.fromList(hexToBytes(txin.txId).reversed.toList());
+
+        Uint8List txoutIndexBytes = packUint32LE(txin.txIndex);
+        hashPrevouts = Uint8List.fromList([...hashPrevouts, ...txidBytes, ...txoutIndexBytes]);
+      }
+      hashPrevouts = singleHash(hashPrevouts);
+      txForSign.add(hashPrevouts);
+
+      for (final i in amounts) {
+        Uint8List bytes = packBigIntToLittleEndian(i);
+
+        hashAmounts = Uint8List.fromList([...hashAmounts, ...bytes]);
+      }
+      hashAmounts = singleHash(hashAmounts);
+      txForSign.add(hashAmounts);
+
+      for (final s in scriptPubKeys) {
+        final h = s.toHex();
+
+        /// must checked
+        int scriptLen = h.length ~/ 2;
+        Uint8List scriptBytes = hexToBytes(h);
+        Uint8List lenBytes = Uint8List.fromList([scriptLen]);
+        hashScriptPubkeys = Uint8List.fromList([...hashScriptPubkeys, ...lenBytes, ...scriptBytes]);
+      }
+      hashScriptPubkeys = singleHash(hashScriptPubkeys);
+      txForSign.add(hashScriptPubkeys);
+
+      for (final txIn in newTx.inputs) {
+        hashSequences = Uint8List.fromList([...hashSequences, ...txIn.sequence]);
+      }
+      hashSequences = singleHash(hashSequences);
+      txForSign.add(hashSequences);
+    }
+    if (!(sighashNone || sighashSingle)) {
+      for (final txOut in newTx.outputs) {
+        Uint8List packedAmount = packBigIntToLittleEndian(txOut.amount);
+        Uint8List scriptBytes = txOut.scriptPubKey.toBytes();
+        final lenScriptBytes = Uint8List.fromList([scriptBytes.length]);
+        hashOutputs = Uint8List.fromList(
+            [...hashOutputs, ...packedAmount, ...lenScriptBytes, ...scriptBytes]);
+      }
+      hashOutputs = singleHash(hashOutputs);
+      txForSign.add(hashOutputs);
+    }
+
+    final int spendType = extFlags * 2 + 0;
+    txForSign.add(Uint8List.fromList([spendType]));
+
+    if (anyoneCanPay) {
+      final txin = newTx.inputs[txIndex];
+      Uint8List txidBytes = Uint8List.fromList(hexToBytes(txin.txId).reversed.toList());
+      Uint8List txoutIndexBytes = packUint32LE(txin.txIndex);
+      Uint8List result = Uint8List.fromList([...txidBytes, ...txoutIndexBytes]);
+      txForSign.add(result);
+      txForSign.add(packBigIntToLittleEndian(amounts[txIndex]));
+      final sPubKey = scriptPubKeys[txIndex].toHex();
+      final sLength = sPubKey.length ~/ 2;
+      txForSign.add(Uint16List.fromList([sLength]));
+      txForSign.add(hexToBytes(sPubKey));
+      txForSign.add(txin.sequence);
+    } else {
+      int index = txIndex;
+      ByteData byteData = ByteData(4);
+      for (int i = 0; i < 4; i++) {
+        byteData.setUint8(i, index & 0xFF);
+        index >>= 8;
+      }
+      Uint8List bytes = byteData.buffer.asUint8List();
+      txForSign.add(bytes);
+    }
+    if (sighashSingle) {
+      final txOut = newTx.outputs[txIndex];
+
+      Uint8List packedAmount = packBigIntToLittleEndian(txOut.amount);
+      final sBytes = txOut.scriptPubKey.toBytes();
+      Uint8List lenScriptBytes = Uint8List.fromList([sBytes.length]);
+
+      final hashOut = Uint8List.fromList([...packedAmount, ...lenScriptBytes, ...sBytes]);
+      txForSign.add(singleHash(hashOut));
+    }
+    if (extFlags == 1) {
+      leafVar = LEAF_VERSION_TAPSCRIPT;
+      final leafVarBytes = Uint8List.fromList([
+        ...Uint8List.fromList([leafVar]),
+        ...prependVarint(script.toBytes())
+      ]);
+      txForSign.add(taggedHash(leafVarBytes, "TapLeaf"));
+      txForSign.add(Uint16List.fromList([0]));
+      txForSign.add(Uint8List.fromList([0xFF, 0xFF, 0xFF, 0xFF]));
+    }
+    final bytes = txForSign.toBytes();
+    txForSign.close();
+    return taggedHash(bytes, "TapSighash");
+  }
+
+  /// converts result of to_bytes to hexadecimal string
+  String toHex() {
+    final bytes = toBytes(segwit: hasSegwit);
+    return bytesToHex(bytes);
+  }
+
+  /// converts result of to_bytes to hexadecimal string
+  String serialize() {
+    return toHex();
+  }
+
+  /// Calculates the tx size
+  int getSize() {
+    return toBytes(segwit: hasSegwit).length;
+  }
+
+  /// Calculates the tx segwit size
+  int getVSize() {
+    if (!hasSegwit) return getSize();
+    int markerSize = 2;
+    int witSize = 0;
+    Uint8List data = Uint8List(0);
+    for (final w in witnesses) {
+      final countBytes = Uint8List.fromList([w.stack.length]);
+      data = Uint8List.fromList([...data, ...countBytes, ...w.toBytes()]);
+    }
+    witSize = data.length;
+    int size = getSize() - (markerSize + witSize);
+    double vSize = size + (markerSize + witSize) / 4;
+    return vSize.ceil();
+  }
+
+  /// Calculates txid and returns it
+  String txId() {
+    final bytes = toBytes(segwit: false);
+    final reversedHash = doubleHash(bytes).reversed.toList();
+    return bytesToHex(reversedHash);
+  }
+
+  @override
+  String toString() {
+    this.inputs.forEach((txInput) {
+      print(txInput.toString());
+    });
+    this.outputs.forEach((txOutput) {
+      print(txOutput.toString());
+    });
+    return '';
+  }
+}
diff --git a/lib/src/payments/bitcoin/transaction_builder.dart b/lib/src/payments/bitcoin/transaction_builder.dart
new file mode 100644
index 0000000..11ab24e
--- /dev/null
+++ b/lib/src/payments/bitcoin/transaction_builder.dart
@@ -0,0 +1,507 @@
+import 'dart:convert';
+import 'dart:typed_data';
+
+import 'package:bitcoin_flutter/src/utils/script.dart';
+import 'package:bitcoin_flutter/src/utils/uint8list.dart';
+import 'package:bitcoin_flutter/src/utils/string.dart';
+import 'package:bitcoin_flutter/src/payments/address/core.dart';
+import 'package:bitcoin_flutter/src/payments/address/segwit_address.dart';
+import 'package:bitcoin_flutter/src/payments/script/script.dart';
+import 'package:bitcoin_flutter/src/payments/bitcoin/input.dart';
+import 'package:bitcoin_flutter/src/payments/bitcoin/output.dart';
+import 'package:bitcoin_flutter/src/payments/bitcoin/witness.dart';
+import 'package:bitcoin_flutter/src/payments/bitcoin/transaction.dart';
+import 'package:bitcoin_flutter/src/payments/constants/constants.dart';
+import 'package:bitcoin_flutter/src/models/networks.dart';
+import 'package:bitcoin_flutter/src/ecpair.dart';
+import 'package:bitcoin_flutter/src/payments/bitcoin/utxo_details.dart';
+
+typedef BitcoinSignerCallBack = String Function(
+    Uint8List trDigest, UtxoWithOwner utxo, String publicKey);
+
+class BitcoinTransactionBuilder {
+  final List<BitcoinOutputDetails> outputs;
+  final BigInt fee;
+  final List<UtxoWithOwner> utxos;
+  late final NetworkType network;
+  final String? memo;
+  final bool enableRBF;
+  final bool isFakeTransaction;
+  int maximumFeeRate;
+
+  bool _hasSegwit = false;
+  bool _hasTaproot = false;
+
+  BitcoinTransactionBuilder({
+    required this.outputs,
+    required this.fee,
+    required this.utxos,
+    this.memo = '',
+    this.enableRBF = false,
+    this.maximumFeeRate = 2500,
+    this.isFakeTransaction = false,
+    NetworkType? network,
+  }) {
+    for (final element in utxos) {
+      if (element.utxo.isSegwit()) {
+        _hasSegwit = true;
+      }
+      if (element.utxo.isP2tr()) {
+        _hasTaproot = true;
+      }
+    }
+  }
+
+  /// HasSegwit checks whether any of the unspent transaction outputs (UTXOs) in the BitcoinTransactionBuilder's
+  /// Utxos list are Segregated Witness (SegWit) UTXOs. It iterates through the Utxos list and returns true if it
+  /// finds any UTXO with a SegWit script type; otherwise, it returns false.
+  bool get hasSegwit => _hasSegwit;
+
+  /// HasTaproot checks whether any of the unspent transaction outputs (UTXOs) in the BitcoinTransactionBuilder's
+  /// Utxos list are Pay-to-Taproot (P2TR) UTXOs. It iterates through the Utxos list and returns true if it finds
+  /// any UTXO with a Taproot script type; otherwise, it returns false.
+  bool get hasTaproot => _hasTaproot;
+
+  /// This method is used to create a dummy transaction,
+  /// allowing us to obtain the size of the original transaction
+  /// before conducting the actual transaction. This helps us estimate the transaction cost
+  static int estimateTransactionSize(
+      {required List<UtxoWithOwner> utxos,
+      required List<BitcoinAddress> outputs,
+      required NetworkType network,
+      String? memo,
+      bool enableRBF = false}) {
+    final sum = utxos.sumOfUtxosValue();
+
+    /// We consider the total amount for the output because,
+    /// in all cases, the size of the amount is 8 bytes.
+    final outs = outputs.map((e) => BitcoinOutputDetails(address: e, value: sum)).toList();
+    final transactionBuilder = BitcoinTransactionBuilder(
+      /// Now, we provide the UTXOs we want to spend.
+      utxos: utxos,
+
+      /// We select transaction outputs
+      outputs: outs,
+      /*
+			Transaction fee
+			Ensure that you have accurately calculated the amounts.
+			If the sum of the outputs, including the transaction fee,
+			does not match the total amount of UTXOs,
+			it will result in an error. Please double-check your calculations.
+		*/
+      fee: BigInt.from(0),
+
+      /// network, testnet, mainnet
+      network: network,
+
+      /// If you like the note write something else and leave it blank
+      memo: memo,
+      /*
+			RBF, or Replace-By-Fee, is a feature in Bitcoin that allows you to increase the fee of an unconfirmed
+			transaction that you've broadcasted to the network.
+			This feature is useful when you want to speed up a
+			transaction that is taking longer than expected to get confirmed due to low transaction fees.
+		*/
+      enableRBF: true,
+
+      /// We consider the transaction to be fake so that it doesn't check the amounts
+      /// and doesn't generate errors when determining the transaction size.
+      isFakeTransaction: true,
+    );
+    ECPair? fakePrivate;
+    final transaction = transactionBuilder.buildTransaction((trDigest, utxo, multiSigPublicKey) {
+      fakePrivate ??= ECPair.makeRandom();
+      if (utxo.utxo.isP2tr()) {
+        return fakePrivate!.signTapRoot(trDigest).hex;
+      } else {
+        return fakePrivate!.sign(trDigest).hex;
+      }
+    }, []);
+
+    /// Now we need the size of the transaction. If the transaction is a SegWit transaction,
+    /// we use the getVSize method; otherwise, we use the getSize method to obtain the transaction size
+    final size = transaction.hasSegwit ? transaction.getVSize() : transaction.getSize();
+
+    return size;
+  }
+
+  /// It is used to make the appropriate scriptSig
+  Script buildInputScriptPubKeys(UtxoWithOwner utxo, bool isTaproot) {
+    if (utxo.isMultiSig()) {
+      final script = Script.fromRaw(
+          hexData: utxo.ownerDetails.multiSigAddress!.scriptDetails, hasSegwit: true);
+      switch (utxo.ownerDetails.multiSigAddress!.address.type) {
+        case AddressType.p2wshInP2sh:
+          if (isTaproot) {
+            return utxo.ownerDetails.multiSigAddress!.address.scriptPubkey;
+          }
+          return script;
+        case AddressType.p2wsh:
+          if (isTaproot) {
+            return utxo.ownerDetails.multiSigAddress!.address.scriptPubkey;
+          }
+          return script;
+        default:
+          return Script(script: []);
+      }
+    }
+
+    final senderPub = utxo.public();
+    switch (utxo.utxo.scriptType) {
+      case AddressType.p2pk:
+        return senderPub.toRedeemScript();
+      case AddressType.p2wsh:
+        if (isTaproot) {
+          return senderPub.toP2wshAddress().scriptPubkey;
+        }
+        return senderPub.toP2wshScript();
+      case AddressType.p2pkh:
+        return senderPub.toAddress().scriptPubkey;
+      case AddressType.p2wpkh:
+        if (isTaproot) {
+          return senderPub.toSegwitAddress().scriptPubkey;
+        }
+        return senderPub.toAddress().scriptPubkey;
+      case AddressType.p2tr:
+        return senderPub.toTaprootAddress().scriptPubkey;
+      case AddressType.p2pkhInP2sh:
+        if (isTaproot) {
+          return senderPub.toP2pkhInP2sh().scriptPubkey;
+        }
+        return senderPub.toAddress().scriptPubkey;
+      case AddressType.p2wpkhInP2sh:
+        if (isTaproot) {
+          return senderPub.toP2wpkhInP2sh().scriptPubkey;
+        }
+        return senderPub.toAddress().scriptPubkey;
+      case AddressType.p2wshInP2sh:
+        if (isTaproot) {
+          return senderPub.toP2wshInP2sh().scriptPubkey;
+        }
+        return senderPub.toP2wshScript();
+      case AddressType.p2pkInP2sh:
+        if (isTaproot) {
+          return senderPub.toP2pkInP2sh().scriptPubkey;
+        }
+        return senderPub.toRedeemScript();
+      default:
+        return Script(script: []);
+    }
+  }
+
+  /// generateTransactionDigest generates and returns a transaction digest for a given input in the context of a Bitcoin
+  /// transaction. The digest is used for signing the transaction input. The function takes into account whether the
+  /// associated UTXO is Segregated Witness (SegWit) or Pay-to-Taproot (P2TR), and it computes the appropriate digest
+  /// based on these conditions.
+  //
+  /// Parameters:
+  /// - scriptPubKeys: representing the scriptPubKey for the transaction output being spent.
+  /// - input: An integer indicating the index of the input being processed within the transaction.
+  /// - utox: A UtxoWithOwner instance representing the unspent transaction output (UTXO) associated with the input.
+  /// - transaction: A BtcTransaction representing the Bitcoin transaction being constructed.
+  /// - taprootAmounts: A List of BigInt containing taproot-specific amounts for P2TR inputs (ignored for non-P2TR inputs).
+  /// - tapRootPubKeys: A List of of Script representing taproot public keys for P2TR inputs (ignored for non-P2TR inputs).
+  //
+  /// Returns:
+  /// - Uint8List: representing the transaction digest to be used for signing the input.
+  Uint8List generateTransactionDigest(Script scriptPubKeys, int input, UtxoWithOwner utox,
+      BtcTransaction transaction, List<BigInt> taprootAmounts, List<Script> tapRootPubKeys) {
+    if (utox.utxo.isSegwit()) {
+      if (utox.utxo.isP2tr()) {
+        return transaction.getTransactionTaprootDigset(
+          txIndex: input,
+          scriptPubKeys: tapRootPubKeys,
+          amounts: taprootAmounts,
+        );
+      }
+      return transaction.getTransactionSegwitDigit(
+          txInIndex: input, script: scriptPubKeys, amount: utox.utxo.value);
+    }
+    return transaction.getTransactionDigest(txInIndex: input, script: scriptPubKeys);
+  }
+
+  /// buildP2wshOrP2shScriptSig constructs and returns a script signature (represented as a List of strings)
+  /// for a Pay-to-Witness-Script-Hash (P2WSH) or Pay-to-Script-Hash (P2SH) input. The function combines the
+  /// signed transaction digest with the script details of the multi-signature address owned by the UTXO owner.
+  //
+  /// Parameters:
+  /// - signedDigest: A List of strings containing the signed transaction digest elements.
+  /// - utx: A UtxoWithOwner instance representing the unspent transaction output (UTXO) and its owner details.
+  //
+  /// Returns:
+  /// - List<String>: A List of strings representing the script signature for the P2WSH or P2SH input.
+  List<String> buildP2wshOrP2shScriptSig(List<String> signedDigest, UtxoWithOwner utx) {
+    /// The constructed script signature consists of the signed digest elements followed by
+    /// the script details of the multi-signature address.
+    return ['', ...signedDigest, utx.ownerDetails.multiSigAddress!.scriptDetails];
+  }
+
+  /// buildP2shSegwitRedeemScriptSig constructs and returns a script signature (represented as a List of strings)
+  /// for a Pay-to-Script-Hash (P2SH) Segregated Witness (SegWit) input. The function determines the script type
+  /// based on the UTXO and UTXO owner details and creates the appropriate script signature.
+  //
+  /// Parameters:
+  /// - utx0: A UtxoWithOwner instance representing the unspent transaction output (UTXO) and its owner details.
+  //
+  /// Returns:
+  /// - List<string>: A List of strings representing the script signature for the P2SH SegWit input.
+  List<String> buildP2shSegwitRedeemScriptSig(UtxoWithOwner utx0) {
+    if (utx0.isMultiSig()) {
+      switch (utx0.ownerDetails.multiSigAddress!.address.type) {
+        case AddressType.p2wshInP2sh:
+          final script = Script.fromRaw(
+              hexData: utx0.ownerDetails.multiSigAddress!.scriptDetails, hasSegwit: true);
+          final p2wsh = P2wshAddress(script: script);
+          return [p2wsh.scriptPubkey.toHex()];
+        default:
+          throw Exception('Does not support this script type');
+      }
+    }
+    final senderPub = utx0.public();
+    switch (utx0.utxo.scriptType) {
+      case AddressType.p2wshInP2sh:
+        final script = senderPub.toP2wshAddress().scriptPubkey;
+        return [script.toHex()];
+      case AddressType.p2wpkhInP2sh:
+        final script = senderPub.toSegwitAddress().scriptPubkey;
+        return [script.toHex()];
+      default:
+        throw Exception('Does not support this script type');
+    }
+  }
+
+/*
+Unlocking Script (scriptSig): The scriptSig is also referred to as
+the unlocking script because it provides data and instructions to unlock
+a specific output. It contains information and cryptographic signatures
+that demonstrate the right to spend the bitcoins associated with the corresponding scriptPubKey output.
+*/
+  List<String> buildScriptSig(String signedDigest, UtxoWithOwner utx) {
+    final senderPub = utx.public();
+    if (utx.utxo.isSegwit()) {
+      if (utx.utxo.isP2tr()) {
+        return [signedDigest];
+      }
+      switch (utx.utxo.scriptType) {
+        case AddressType.p2wshInP2sh:
+        case AddressType.p2wsh:
+          final script = senderPub.toP2wshScript();
+          return ['', signedDigest, script.toHex()];
+        default:
+          return [signedDigest, senderPub.toHex()];
+      }
+    } else {
+      switch (utx.utxo.scriptType) {
+        case AddressType.p2pk:
+          return [signedDigest];
+        case AddressType.p2pkh:
+          return [signedDigest, senderPub.toHex()];
+        case AddressType.p2pkhInP2sh:
+          final script = senderPub.toAddress().scriptPubkey;
+          return [signedDigest, senderPub.toHex(), script.toHex()];
+        case AddressType.p2pkInP2sh:
+          final script = senderPub.toRedeemScript();
+          return [signedDigest, script.toHex()];
+        default:
+          throw Exception('Cannot send from this type of address ${utx.utxo.scriptType}');
+      }
+    }
+  }
+
+  List<TxInput> buildInputs() {
+    final sequence = enableRBF
+        ? (Sequence(seqType: TYPE_REPLACE_BY_FEE, value: 0, isTypeBlock: true)).forInputSequence()
+        : null;
+    final inputs = <TxInput>[];
+    for (int i = 0; i < utxos.length; i++) {
+      final e = utxos[i];
+      inputs.add(TxInput(
+          txId: e.utxo.txHash,
+          txIndex: e.utxo.vout,
+          sequence: i == 0 && enableRBF ? sequence : null));
+    }
+    return inputs;
+  }
+
+  List<TxOutput> buildOutputs() {
+    final outs = <TxOutput>[];
+    for (final e in outputs) {
+      outs.add(TxOutput(amount: e.value, scriptPubKey: buildOutputScriptPubKey(e)));
+    }
+    return outs;
+  }
+
+/*
+the scriptPubKey of a UTXO (Unspent Transaction Output) is used as the locking
+script that defines the spending conditions for the bitcoins associated
+with that UTXO. When creating a Bitcoin transaction, the spending conditions
+specified by the scriptPubKey must be satisfied by the corresponding scriptSig
+in the transaction input to spend the UTXO.
+*/
+  Script buildOutputScriptPubKey(BitcoinOutputDetails addr) {
+    return addr.address.scriptPubkey;
+  }
+
+/*
+The primary use case for OP_RETURN is data storage. You can embed various types of
+data within the OP_RETURN output, such as text messages, document hashes, or metadata
+related to a transaction. This data is permanently recorded on the blockchain and can
+be retrieved by anyone who examines the blockchain's history.
+*/
+  Script opReturn(String message) {
+    try {
+      message.fromHex;
+      return Script(script: ["OP_RETURN", message]);
+
+      /// ignore: empty_catches
+    } catch (e) {}
+    final toBytes = utf8.encode(message);
+    final toHex = Uint8List.fromList(toBytes).hex;
+    return Script(script: ["OP_RETURN", toHex]);
+  }
+
+  /// Total amount to spend excluding fees
+  BigInt sumOutputAmounts() {
+    BigInt sum = BigInt.zero;
+    for (final e in outputs) {
+      sum += e.value;
+    }
+    return sum;
+  }
+
+  BtcTransaction buildTransaction(BitcoinSignerCallBack sign, List<Script> scriptPubKeys) {
+    /// build inputs
+    final inputs = buildInputs();
+
+    /// build outout
+    final outputs = buildOutputs();
+
+    /// check if you set memos or not
+    // if (memo != null) {
+    //   outputs.add(TxOutput(amount: BigInt.zero, scriptPubKey: opReturn(memo!)));
+    // }
+
+    /// create new transaction with inputs and outputs and isSegwit transaction or not
+    final transaction = BtcTransaction(
+        inputs: inputs, outputs: outputs, hasSegwit: hasSegwit, hasTaproot: hasTaproot);
+
+    /// we define empty witnesses. maybe the transaction is segwit and We need this
+    final wintnesses = <TxWitnessInput>[];
+
+    /// when the transaction is taproot and we must use getTaproot tansaction digest
+    /// we need all of inputs amounts and owner script pub keys
+    List<BigInt> taprootAmounts = [];
+    List<Script> taprootScripts = scriptPubKeys;
+
+    if (hasTaproot) {
+      taprootAmounts = utxos.map((e) => e.utxo.value).toList();
+      if (taprootScripts.isEmpty)
+        taprootScripts = utxos.map((e) => buildInputScriptPubKeys(e, true)).toList();
+    }
+
+    /// Well, now let's do what we want for each input
+    for (int i = 0; i < inputs.length; i++) {
+      /// We receive the owner's ScriptPubKey
+      final script = buildInputScriptPubKeys(utxos[i], false);
+
+      /// We generate transaction digest for current input
+      print(["signatur", script, utxos[i], transaction, taprootAmounts, scriptPubKeys]);
+      final digest = generateTransactionDigest(
+          script, i, utxos[i], transaction, taprootAmounts, scriptPubKeys);
+
+      /// handle multisig address
+      if (utxos[i].isMultiSig()) {
+        final multiSigAddress = utxos[i].ownerDetails.multiSigAddress;
+        int sumMultiSigWeight = 0;
+        final mutlsiSigSignatures = <String>[];
+        for (int ownerIndex = 0; ownerIndex < multiSigAddress!.signers.length; ownerIndex++) {
+          /// now we need sign the transaction digest
+          var sig = sign(digest, utxos[i], multiSigAddress.signers[ownerIndex].publicKey);
+          if (!hasTaproot) {
+            sig = encodeSignature(sig.fromHex).hex;
+          }
+          if (sig.isEmpty) continue;
+          for (int weight = 0; weight < multiSigAddress.signers[ownerIndex].weight; weight++) {
+            if (mutlsiSigSignatures.length >= multiSigAddress.threshold) {
+              break;
+            }
+            mutlsiSigSignatures.add(sig);
+          }
+          sumMultiSigWeight += multiSigAddress.signers[ownerIndex].weight;
+          if (sumMultiSigWeight >= multiSigAddress.threshold) {
+            break;
+          }
+        }
+        if (sumMultiSigWeight != multiSigAddress.threshold) {
+          throw StateError("some multisig signature does not exist");
+        }
+
+        /// ok we signed, now we need unlocking script for this input
+        final scriptSig = buildP2wshOrP2shScriptSig(mutlsiSigSignatures, utxos[i]);
+
+        /// Now we need to add it to the transaction
+        /// check if current utxo is segwit or not
+        wintnesses.add(TxWitnessInput(stack: scriptSig));
+        if (utxos[i].utxo.isP2shSegwit()) {
+          /*
+				check if we need redeemScriptSig or not
+				In a Pay-to-Script-Hash (P2SH) Segregated Witness (SegWit) input,
+				the redeemScriptSig is needed for historical and compatibility reasons,
+				even though the actual script execution has moved to the witness field (the witnessScript).
+				This design choice preserves backward compatibility with older Bitcoin clients that do not support SegWit.
+			*/
+          final p2shSegwitScript = buildP2shSegwitRedeemScriptSig(utxos[i]);
+          inputs[i].scriptSig = Script(script: p2shSegwitScript);
+        }
+        continue;
+      }
+
+      /// now we need sign the transaction digest
+      var sig = sign(digest, utxos[i], utxos[i].ownerDetails.publicKey!);
+
+      if (!hasTaproot) {
+        sig = encodeSignature(sig.fromHex).hex;
+      }
+
+      /// ok we signed, now we need unlocking script for this input
+      final scriptSig = buildScriptSig(sig, utxos[i]);
+
+      /// Now we need to add it to the transaction
+      /// check if current utxo is segwit or not
+      if (utxos[i].utxo.isSegwit()) {
+        /// ok is segwit and we append to witness list
+        wintnesses.add(TxWitnessInput(stack: scriptSig));
+        if (utxos[i].utxo.isP2shSegwit()) {
+          /*
+				check if we need redeemScriptSig or not
+				In a Pay-to-Script-Hash (P2SH) Segregated Witness (SegWit) input,
+				the redeemScriptSig is needed for historical and compatibility reasons,
+				even though the actual script execution has moved to the witness field (the witnessScript).
+				This design choice preserves backward compatibility with older Bitcoin clients that do not support SegWit.
+			*/
+          final p2shSegwitScript = buildP2shSegwitRedeemScriptSig(utxos[i]);
+          inputs[i].scriptSig = Script(script: p2shSegwitScript);
+        }
+      } else {
+        /// ok input is not segwit and we use SetScriptSig to set the correct scriptSig
+        inputs[i].scriptSig = Script(script: scriptSig);
+        /*
+			 the concept of an "empty witness" is related to Segregated Witness (SegWit) transactions
+			 and the way transaction data is structured. When a transaction input is not associated
+			 with a SegWit UTXO, it still needs to be compatible with
+			 the SegWit transaction format. This is achieved through the use of an "empty witness."
+			*/
+        if (hasSegwit) {
+          wintnesses.add(TxWitnessInput(stack: []));
+        }
+      }
+    }
+
+    /// ok we now check if the transaction is segwit We add all witnesses to the transaction
+    if (hasSegwit) {
+      transaction.witnesses.addAll(wintnesses);
+    }
+
+    return transaction;
+  }
+}
diff --git a/lib/src/payments/bitcoin/utxo_details.dart b/lib/src/payments/bitcoin/utxo_details.dart
new file mode 100644
index 0000000..51fe830
--- /dev/null
+++ b/lib/src/payments/bitcoin/utxo_details.dart
@@ -0,0 +1,127 @@
+/// UtxoOwnerDetails represents ownership details associated with a Bitcoin unspent transaction output (UTXO).
+/// It includes information such as the public key, Bitcoin address, and multi-signature address (if applicable)
+/// of the UTXO owner.
+import 'package:bitcoin_flutter/src/payments/address/core.dart';
+import 'package:bitcoin_flutter/src/ec/ec_public.dart';
+
+import 'multisig_script.dart';
+
+class UtxoOwnerDetails {
+  /// PublicKey is the public key associated with the UTXO owner.
+  final String? publicKey;
+
+  /// Address is the Bitcoin address associated with the UTXO owner.
+  final BitcoinAddress address;
+
+  /// MultiSigAddress is a pointer to a MultiSignaturAddress instance representing a multi-signature address
+  /// associated with the UTXO owner. It may be null if the UTXO owner is not using a multi-signature scheme.
+  final MultiSignatureAddress? multiSigAddress;
+
+  UtxoOwnerDetails({
+    this.publicKey,
+    required this.address,
+    this.multiSigAddress,
+  }) : assert(publicKey != null || multiSigAddress != null,
+            "use publicKey for normal transaction and multiSigAddress for multi-sig address");
+}
+
+/// UtxoWithOwner represents an unspent transaction output (UTXO) along with its associated owner details.
+/// It combines information about the UTXO itself (BitcoinUtxo) and the ownership details (UtxoOwnerDetails).
+class UtxoWithOwner {
+  /// Utxo is a BitcoinUtxo instance representing the unspent transaction output.
+  final BitcoinUtxo utxo;
+
+  /// OwnerDetails is a UtxoOwnerDetails instance containing information about the UTXO owner.
+  final UtxoOwnerDetails ownerDetails;
+
+  UtxoWithOwner({
+    required this.utxo,
+    required this.ownerDetails,
+  });
+
+  ECPublic public() {
+    if (isMultiSig()) {
+      throw ArgumentError(
+          "Cannot access public key in multi-signature address; use owner's public keys");
+    }
+    return ECPublic.fromHex(ownerDetails.publicKey!);
+  }
+
+  bool isMultiSig() {
+    return ownerDetails.multiSigAddress != null;
+  }
+}
+
+/// BitcoinOutputDetails represents details about a Bitcoin transaction output, including
+/// the recipient address and the value of bitcoins sent to that address.
+class BitcoinOutputDetails {
+  /// Address is a Bitcoin address representing the recipient of the transaction output.
+  final BitcoinAddress address;
+
+  /// Value is a pointer to a BigInt representing the amount of bitcoins sent to the recipient.
+  final BigInt value;
+
+  BitcoinOutputDetails({
+    required this.address,
+    required this.value,
+  });
+}
+
+/// BitcoinUtxo represents an unspent transaction output (UTXO) on the Bitcoin blockchain.
+/// It includes details such as the transaction hash (TxHash), the amount of bitcoins (Value),
+/// the output index (Vout), the script type (ScriptType), and the block height at which the UTXO
+/// was confirmed (BlockHeight).
+class BitcoinUtxo {
+  /// TxHash is the unique identifier of the transaction containing this UTXO.
+  final String txHash;
+
+  /// Value is a pointer to a BigInt representing the amount of bitcoins associated with this UTXO.
+  final BigInt value;
+
+  /// Vout is the output index within the transaction that corresponds to this UTXO.
+  final int vout;
+
+  /// ScriptType specifies the type of Bitcoin script associated with this UTXO.
+  final AddressType scriptType;
+
+  /// BlockHeight represents the block height at which this UTXO was confirmed.
+  final int blockHeight;
+
+  BitcoinUtxo({
+    required this.txHash,
+    required this.value,
+    required this.vout,
+    required this.scriptType,
+    required this.blockHeight,
+  });
+
+  bool isP2tr() {
+    return scriptType == AddressType.p2tr;
+  }
+
+  bool isSegwit() {
+    return scriptType == AddressType.p2wpkh ||
+        scriptType == AddressType.p2wsh ||
+        scriptType == AddressType.p2tr ||
+        isP2shSegwit();
+  }
+
+  bool isP2shSegwit() {
+    return scriptType == AddressType.p2wpkhInP2sh || scriptType == AddressType.p2wshInP2sh;
+  }
+}
+
+extension Calculate on List<UtxoWithOwner> {
+  BigInt sumOfUtxosValue() {
+    BigInt sum = BigInt.zero;
+    for (var utxo in this) {
+      sum += utxo.utxo.value;
+    }
+    return sum;
+  }
+
+  bool canSpend() {
+    final value = sumOfUtxosValue();
+    return value.compareTo(BigInt.zero) != 0;
+  }
+}
diff --git a/lib/src/payments/bitcoin/witness.dart b/lib/src/payments/bitcoin/witness.dart
new file mode 100644
index 0000000..4e5cf3d
--- /dev/null
+++ b/lib/src/payments/bitcoin/witness.dart
@@ -0,0 +1,27 @@
+import 'dart:typed_data';
+import 'package:bitcoin_flutter/src/formatting/bytes_num_formatting.dart';
+
+/// A list of the witness items required to satisfy the locking conditions of a segwit input (aka witness stack).
+///
+/// [stack] the witness items (hex str) list
+class TxWitnessInput {
+  TxWitnessInput({required this.stack});
+  final List<String> stack;
+
+  /// creates a copy of the object (classmethod)
+  TxWitnessInput copy() {
+    return TxWitnessInput(stack: List.from(stack, growable: false));
+  }
+
+  /// returns a serialized byte version of the witness items list
+  Uint8List toBytes() {
+    Uint8List stackBytes = Uint8List(0);
+
+    for (String item in stack) {
+      Uint8List itemBytes = prependVarint(hexToBytes(item));
+      stackBytes = Uint8List.fromList([...stackBytes, ...itemBytes]);
+    }
+
+    return stackBytes;
+  }
+}
diff --git a/lib/src/payments/constants/constants.dart b/lib/src/payments/constants/constants.dart
new file mode 100644
index 0000000..2f385f5
--- /dev/null
+++ b/lib/src/payments/constants/constants.dart
@@ -0,0 +1,370 @@
+import 'dart:typed_data';
+
+import 'package:hex/hex.dart';
+
+/// ignore_for_file: constant_identifier_names, equal_keys_in_map, non_constant_identifier_names
+/// Constants and identifiers used in the Bitcoin-related code.
+// ignore_for_file: constant_identifier_names, non_constant_identifier_names, equal_keys_in_map
+
+enum OP_WORDS {
+  OP_0,
+  OP_FALSE,
+  OP_PUSHDATA1,
+  OP_PUSHDATA2,
+  OP_PUSHDATA4,
+  OP_1NEGATE,
+  OP_1,
+  OP_TRUE,
+  OP_2,
+  OP_3,
+  OP_4,
+  OP_5,
+  OP_6,
+  OP_7,
+  OP_8,
+  OP_9,
+  OP_10,
+  OP_11,
+  OP_12,
+  OP_13,
+  OP_14,
+  OP_15,
+  OP_16,
+  OP_NOP,
+  OP_IF,
+  OP_NOTIF,
+  OP_ELSE,
+  OP_ENDIF,
+  OP_VERIFY,
+  OP_RETURN,
+  OP_TOALTSTACK,
+  OP_FROMALTSTACK,
+  OP_IFDUP,
+  OP_DEPTH,
+  OP_DROP,
+  OP_DUP,
+  OP_NIP,
+  OP_OVER,
+  OP_PICK,
+  OP_ROLL,
+  OP_ROT,
+  OP_SWAP,
+  OP_TUCK,
+  OP_2DROP,
+  OP_2DUP,
+  OP_3DUP,
+  OP_2OVER,
+  OP_2ROT,
+  OP_2SWAP,
+  OP_SIZE,
+  OP_EQUAL,
+  OP_EQUALVERIFY,
+  OP_1ADD,
+  OP_1SUB,
+  OP_NEGATE,
+  OP_ABS,
+  OP_NOT,
+  OP_0NOTEQUAL,
+  OP_ADD,
+  OP_SUB,
+  OP_BOOLAND,
+  OP_BOOLOR,
+  OP_NUMEQUAL,
+  OP_NUMEQUALVERIFY,
+  OP_NUMNOTEQUAL,
+  OP_LESSTHAN,
+  OP_GREATERTHAN,
+  OP_LESSTHANOREQUAL,
+  OP_GREATERTHANOREQUAL,
+  OP_MIN,
+  OP_MAX,
+  OP_WITHIN,
+  OP_RIPEMD160,
+  OP_SHA1,
+  OP_SHA256,
+  OP_HASH160,
+  OP_HASH256,
+  OP_CODESEPARATOR,
+  OP_CHECKSIG,
+  OP_CHECKSIGVERIFY,
+  OP_CHECKMULTISIG,
+  OP_CHECKMULTISIGVERIFY,
+  OP_NOP2,
+  OP_CHECKLOCKTIMEVERIFY,
+  OP_NOP3,
+  OP_CHECKSEQUENCEVERIFY,
+}
+
+const Map<String, List<int>> OP_CODES = {
+  'OP_0': [0x00],
+  'OP_FALSE': [0x00],
+  'OP_PUSHDATA1': [0x4c],
+  'OP_PUSHDATA2': [0x4d],
+  'OP_PUSHDATA4': [0x4e],
+  'OP_1NEGATE': [0x4f],
+  'OP_1': [0x51],
+  'OP_TRUE': [0x51],
+  'OP_2': [0x52],
+  'OP_3': [0x53],
+  'OP_4': [0x54],
+  'OP_5': [0x55],
+  'OP_6': [0x56],
+  'OP_7': [0x57],
+  'OP_8': [0x58],
+  'OP_9': [0x59],
+  'OP_10': [0x5a],
+  'OP_11': [0x5b],
+  'OP_12': [0x5c],
+  'OP_13': [0x5d],
+  'OP_14': [0x5e],
+  'OP_15': [0x5f],
+  'OP_16': [0x60],
+
+  /// flow control
+  'OP_NOP': [0x61],
+  'OP_IF': [0x63],
+  'OP_NOTIF': [0x64],
+  'OP_ELSE': [0x67],
+  'OP_ENDIF': [0x68],
+  'OP_VERIFY': [0x69],
+  'OP_RETURN': [0x6a],
+
+  /// stack
+  'OP_TOALTSTACK': [0x6b],
+  'OP_FROMALTSTACK': [0x6c],
+  'OP_IFDUP': [0x73],
+  'OP_DEPTH': [0x74],
+  'OP_DROP': [0x75],
+  'OP_DUP': [0x76],
+  'OP_NIP': [0x77],
+  'OP_OVER': [0x78],
+  'OP_PICK': [0x79],
+  'OP_ROLL': [0x7a],
+  'OP_ROT': [0x7b],
+  'OP_SWAP': [0x7c],
+  'OP_TUCK': [0x7d],
+  'OP_2DROP': [0x6d],
+  'OP_2DUP': [0x6e],
+  'OP_3DUP': [0x6f],
+  'OP_2OVER': [0x70],
+  'OP_2ROT': [0x71],
+  'OP_2SWAP': [0x72],
+
+  /// splice
+  /// 'OP_CAT': [0x7e],
+  /// 'OP_SUBSTR': [0x7f],
+  /// 'OP_LEFT': [0x80],
+  /// 'OP_RIGHT': [0x81],
+  'OP_SIZE': [0x82],
+
+  /// bitwise logic
+  /// 'OP_INVERT': [0x83],
+  /// 'OP_AND': [0x84],
+  /// 'OP_OR': [0x85],
+  /// 'OP_XOR': [0x86],
+  'OP_EQUAL': [0x87],
+  'OP_EQUALVERIFY': [0x88],
+
+  /// arithmetic
+  'OP_1ADD': [0x8b],
+  'OP_1SUB': [0x8c],
+
+  /// 'OP_2MUL': [0x8d],
+  /// 'OP_2DIV': [0x8e],
+  'OP_NEGATE': [0x8f],
+  'OP_ABS': [0x90],
+  'OP_NOT': [0x91],
+  'OP_0NOTEQUAL': [0x92],
+  'OP_ADD': [0x93],
+  'OP_SUB': [0x94],
+
+  /// 'OP_MUL': [0x95],
+  /// 'OP_DIV': [0x96],
+  /// 'OP_MOD': [0x97],
+  /// 'OP_LSHIFT': [0x98],
+  /// 'OP_RSHIFT': [0x99],
+  'OP_BOOLAND': [0x9a],
+  'OP_BOOLOR': [0x9b],
+  'OP_NUMEQUAL': [0x9c],
+  'OP_NUMEQUALVERIFY': [0x9d],
+  'OP_NUMNOTEQUAL': [0x9e],
+  'OP_LESSTHAN': [0x9f],
+  'OP_GREATERTHAN': [0xa0],
+  'OP_LESSTHANOREQUAL': [0xa1],
+  'OP_GREATERTHANOREQUAL': [0xa2],
+  'OP_MIN': [0xa3],
+  'OP_MAX': [0xa4],
+  'OP_WITHIN': [0xa5],
+
+  /// crypto
+  'OP_RIPEMD160': [0xa6],
+  'OP_SHA1': [0xa7],
+  'OP_SHA256': [0xa8],
+  'OP_HASH160': [0xa9],
+  'OP_HASH256': [0xaa],
+  'OP_CODESEPARATOR': [0xab],
+  'OP_CHECKSIG': [0xac],
+  'OP_CHECKSIGVERIFY': [0xad],
+  'OP_CHECKMULTISIG': [0xae],
+  'OP_CHECKMULTISIGVERIFY': [0xaf],
+
+  /// locktime
+  'OP_NOP2': [0xb1],
+  'OP_CHECKLOCKTIMEVERIFY': [0xb1],
+  'OP_NOP3': [0xb2],
+  'OP_CHECKSEQUENCEVERIFY': [0xb2],
+
+  /// reserved words
+  'OP_RESERVED': [0x50],
+  'OP_RESERVED1': [0x89],
+  'OP_RESERVED2': [0x8a],
+};
+
+Map<int, String> CODE_OPS = {
+  /// constants
+  0: 'OP_0',
+  76: 'OP_PUSHDATA1',
+  77: 'OP_PUSHDATA2',
+  78: 'OP_PUSHDATA4',
+  79: 'OP_1NEGATE',
+  81: 'OP_1',
+  82: 'OP_2',
+  83: 'OP_3',
+  84: 'OP_4',
+  85: 'OP_5',
+  86: 'OP_6',
+  87: 'OP_7',
+  88: 'OP_8',
+  89: 'OP_9',
+  90: 'OP_10',
+  91: 'OP_11',
+  92: 'OP_12',
+  93: 'OP_13',
+  94: 'OP_14',
+  95: 'OP_15',
+  96: 'OP_16',
+
+  /// flow control
+  97: 'OP_NOP',
+  99: 'OP_IF',
+  100: 'OP_NOTIF',
+  103: 'OP_ELSE',
+  104: 'OP_ENDIF',
+  105: 'OP_VERIFY',
+  106: 'OP_RETURN',
+
+  /// stack
+  107: 'OP_TOALTSTACK',
+  108: 'OP_FROMALTSTACK',
+  115: 'OP_IFDUP',
+  116: 'OP_DEPTH',
+  117: 'OP_DROP',
+  118: 'OP_DUP',
+  119: 'OP_NIP',
+  120: 'OP_OVER',
+  121: 'OP_PICK',
+  122: 'OP_ROLL',
+  123: 'OP_ROT',
+  124: 'OP_SWAP',
+  125: 'OP_TUCK',
+  109: 'OP_2DROP',
+  110: 'OP_2DUP',
+  111: 'OP_3DUP',
+  112: 'OP_2OVER',
+  113: 'OP_2ROT',
+  114: 'OP_2SWAP',
+
+  /// splice
+  130: 'OP_SIZE',
+
+  /// bitwise logic
+  135: 'OP_EQUAL',
+  136: 'OP_EQUALVERIFY',
+
+  /// arithmetic
+  139: 'OP_1ADD',
+  140: 'OP_1SUB',
+  143: 'OP_NEGATE',
+  144: 'OP_ABS',
+  145: 'OP_NOT',
+  146: 'OP_0NOTEQUAL',
+  147: 'OP_ADD',
+  148: 'OP_SUB',
+  154: 'OP_BOOLAND',
+  155: 'OP_BOOLOR',
+  156: 'OP_NUMEQUAL',
+  157: 'OP_NUMEQUALVERIFY',
+  158: 'OP_NUMNOTEQUAL',
+  159: 'OP_LESSTHAN',
+  160: 'OP_GREATERTHAN',
+  161: 'OP_LESSTHANOREQUAL',
+  162: 'OP_GREATERTHANOREQUAL',
+  163: 'OP_MIN',
+  164: 'OP_MAX',
+  165: 'OP_WITHIN',
+
+  /// crypto
+  166: 'OP_RIPEMD160',
+  167: 'OP_SHA1',
+  168: 'OP_SHA256',
+  169: 'OP_HASH160',
+  170: 'OP_HASH256',
+  171: 'OP_CODESEPARATOR',
+  172: 'OP_CHECKSIG',
+  173: 'OP_CHECKSIGVERIFY',
+  174: 'OP_CHECKMULTISIG',
+  175: 'OP_CHECKMULTISIGVERIFY',
+
+  /// locktime
+  177: 'OP_NOP2',
+  178: 'OP_NOP3',
+  177: 'OP_CHECKLOCKTIMEVERIFY',
+  178: 'OP_CHECKSEQUENCEVERIFY',
+
+  /// reserved words
+  80: 'OP_RESERVED',
+  137: 'OP_RESERVED1',
+  138: 'OP_RESERVED2',
+};
+
+/// SIGHASH types
+const int SIGHASH_SINGLE = 0x03;
+const int SIGHASH_ANYONECANPAY = 0x80;
+const int SIGHASH_ALL = 0x01;
+const int SIGHASH_NONE = 0x02;
+const int TAPROOT_SIGHASH_ALL = 0x00;
+
+/// Transaction lock types
+const int TYPE_ABSOLUTE_TIMELOCK = 0x101;
+const int TYPE_RELATIVE_TIMELOCK = 0x201;
+const int TYPE_REPLACE_BY_FEE = 0x301;
+
+/// Default values and sequences
+const List<int> DEFAULT_TX_LOCKTIME = [0x00, 0x00, 0x00, 0x00];
+const List<int> EMPTY_TX_SEQUENCE = [0x00, 0x00, 0x00, 0x00];
+const List<int> DEFAULT_TX_SEQUENCE = [0xff, 0xff, 0xff, 0xff];
+const List<int> ABSOLUTE_TIMELOCK_SEQUENCE = [0xfe, 0xff, 0xff, 0xff];
+const List<int> REPLACE_BY_FEE_SEQUENCE = [0x01, 0x00, 0x00, 0x00];
+
+/// Script version and Bitcoin-related identifiers
+const int LEAF_VERSION_TAPSCRIPT = 0xc0;
+const List<int> DEFAULT_TX_VERSION = [0x01, 0x00, 0x00, 0x00];
+const List<int> TX_VERSION_2 = [0x02, 0x00, 0x00, 0x00];
+const int SATOSHIS_PER_BITCOIN = 100000000;
+const int NEGATIVE_SATOSHI = -1;
+
+/// Bitcoin address types
+const String P2PKH_ADDRESS = "p2pkh";
+const String P2SH_ADDRESS = "p2sh";
+const String P2WPKH_ADDRESS_V0 = "p2wpkhv0";
+const String P2WSH_ADDRESS_V0 = "p2wshv0";
+const String P2TR_ADDRESS_V1 = "p2trv1";
+
+const DEFAULT_SEQUENCE = 0xffffffff;
+const ADVANCED_TRANSACTION_MARKER = 0x00;
+const ADVANCED_TRANSACTION_FLAG = 0x01;
+final EMPTY_SCRIPT = Uint8List.fromList([]);
+final EMPTY_WITNESS = <Uint8List>[];
+final ZERO = HEX.decode('0000000000000000000000000000000000000000000000000000000000000000');
+final ONE = HEX.decode('0000000000000000000000000000000000000000000000000000000000000001');
+final VALUE_UINT64_MAX = HEX.decode('ffffffffffffffff');
diff --git a/lib/src/payments/constants/constants_lib.dart b/lib/src/payments/constants/constants_lib.dart
new file mode 100644
index 0000000..0719a23
--- /dev/null
+++ b/lib/src/payments/constants/constants_lib.dart
@@ -0,0 +1,26 @@
+library bitcoin_constants;
+
+export 'constants.dart'
+    show
+        SIGHASH_SINGLE,
+        SIGHASH_ANYONECANPAY,
+        TYPE_ABSOLUTE_TIMELOCK,
+        TYPE_RELATIVE_TIMELOCK,
+        TYPE_REPLACE_BY_FEE,
+        SIGHASH_ALL,
+        SIGHASH_NONE,
+        TAPROOT_SIGHASH_ALL,
+        DEFAULT_TX_LOCKTIME,
+        EMPTY_TX_SEQUENCE,
+        DEFAULT_TX_SEQUENCE,
+        ABSOLUTE_TIMELOCK_SEQUENCE,
+        REPLACE_BY_FEE_SEQUENCE,
+        LEAF_VERSION_TAPSCRIPT,
+        DEFAULT_TX_VERSION,
+        SATOSHIS_PER_BITCOIN,
+        NEGATIVE_SATOSHI,
+        P2PKH_ADDRESS,
+        P2SH_ADDRESS,
+        P2WPKH_ADDRESS_V0,
+        P2WSH_ADDRESS_V0,
+        P2TR_ADDRESS_V1;
diff --git a/lib/src/payments/p2pk.dart b/lib/src/payments/p2pk.dart
deleted file mode 100644
index 312d7fa..0000000
--- a/lib/src/payments/p2pk.dart
+++ /dev/null
@@ -1,32 +0,0 @@
-import 'dart:typed_data';
-import 'package:meta/meta.dart';
-import 'package:bip32/src/utils/ecurve.dart' show isPoint;
-import 'package:bs58check/bs58check.dart' as bs58check;
-
-import '../crypto.dart';
-import '../models/networks.dart';
-import '../payments/index.dart' show PaymentData;
-import '../utils/script.dart' as bscript;
-import '../utils/constants/op.dart';
-
-class P2PK {
-  PaymentData data;
-  NetworkType network;
-  P2PK({@required data, network})
-    : this.network = network ?? bitcoin,
-      this.data = data {
-    _init();
-  }
-
-  _init() {
-    if (data.output != null) {
-      if (data.output![data.output!.length - 1] != OPS['OP_CHECKSIG'])
-        throw new ArgumentError('Output is invalid');
-      if (!isPoint(data.output!.sublist(1, -1)))
-        throw new ArgumentError('Output pubkey is invalid');
-    }
-    if (data.input != null) {
-      // TODO
-    }
-  }
-}
diff --git a/lib/src/payments/p2pkh.dart b/lib/src/payments/p2pkh.dart
deleted file mode 100644
index 98e28a1..0000000
--- a/lib/src/payments/p2pkh.dart
+++ /dev/null
@@ -1,115 +0,0 @@
-import 'dart:typed_data';
-import 'package:meta/meta.dart';
-import 'package:bip32/src/utils/ecurve.dart' show isPoint;
-import 'package:bs58check/bs58check.dart' as bs58check;
-
-import '../crypto.dart';
-import '../models/networks.dart';
-import '../payments/index.dart' show PaymentData;
-import '../utils/script.dart' as bscript;
-import '../utils/constants/op.dart';
-
-class P2PKH {
-  PaymentData data;
-  NetworkType network;
-  P2PKH({@required data, network})
-  : this.network = network ?? bitcoin,
-    this.data = data {
-    _init();
-  }
-  _init() {
-    if (data.address != null) {
-      _getDataFromAddress(data.address!);
-      _getDataFromHash();
-    } else if (data.hash != null) {
-      _getDataFromHash();
-    } else if (data.output != null) {
-      if (!isValidOutput(data.output!))
-        throw new ArgumentError('Output is invalid');
-      data.hash = data.output!.sublist(3, 23);
-      _getDataFromHash();
-    } else if (data.pubkey != null) {
-      data.hash = hash160(data.pubkey!);
-      _getDataFromHash();
-      _getDataFromChunk();
-    } else if (data.input != null) {
-      List<dynamic>? _chunks = bscript.decompile(data.input!);
-      _getDataFromChunk(_chunks);
-      if (_chunks?.length != 2) throw new ArgumentError('Input is invalid');
-      if (!bscript.isCanonicalScriptSignature(_chunks![0]))
-        throw new ArgumentError('Input has invalid signature');
-      if (!isPoint(_chunks[1]))
-        throw new ArgumentError('Input has invalid pubkey');
-    } else {
-      throw new ArgumentError('Not enough data');
-    }
-  }
-
-  void _getDataFromChunk([List<dynamic>? _chunks]) {
-    if (data.pubkey == null && _chunks != null) {
-      data.pubkey = (_chunks[1] is int)
-          ? new Uint8List.fromList([_chunks[1]])
-          : _chunks[1];
-      data.hash = hash160(data.pubkey!);
-      _getDataFromHash();
-    }
-    if (data.signature == null && _chunks != null)
-      data.signature = (_chunks[0] is int)
-          ? new Uint8List.fromList([_chunks[0]])
-          : _chunks[0];
-    if (data.input == null && data.pubkey != null && data.signature != null) {
-      data.input = bscript.compile([data.signature, data.pubkey]);
-    }
-  }
-
-  void _getDataFromHash() {
-    if (data.address == null) {
-      final payload = new Uint8List(21);
-      payload.buffer.asByteData().setUint8(0, network.pubKeyHash);
-      payload.setRange(1, payload.length, data.hash!);
-      data.address = bs58check.encode(payload);
-    }
-    if (data.output == null) {
-      data.output = bscript.compile([
-        OPS['OP_DUP'],
-        OPS['OP_HASH160'],
-        data.hash,
-        OPS['OP_EQUALVERIFY'],
-        OPS['OP_CHECKSIG']
-      ]);
-    }
-  }
-
-  void _getDataFromAddress(String address) {
-    Uint8List payload = bs58check.decode(address);
-    final version = payload.buffer.asByteData().getUint8(0);
-    if (version != network.pubKeyHash)
-      throw new ArgumentError('Invalid version or Network mismatch');
-    data.hash = payload.sublist(1);
-    if (data.hash!.length != 20) throw new ArgumentError('Invalid address');
-  }
-}
-
-isValidOutput(Uint8List data) {
-  return data.length == 25 &&
-      data[0] == OPS['OP_DUP'] &&
-      data[1] == OPS['OP_HASH160'] &&
-      data[2] == 0x14 &&
-      data[23] == OPS['OP_EQUALVERIFY'] &&
-      data[24] == OPS['OP_CHECKSIG'];
-}
-
-// Backward compatibility
-@Deprecated(
-    "The 'P2PKHData' class is deprecated. Use the 'PaymentData' package instead.")
-class P2PKHData extends PaymentData {
-  P2PKHData({address, hash, output, pubkey, input, signature, witness})
-      : super(
-            address: address,
-            hash: hash,
-            output: output,
-            pubkey: pubkey,
-            input: input,
-            signature: signature,
-            witness: witness);
-}
diff --git a/lib/src/payments/p2wpkh.dart b/lib/src/payments/p2wpkh.dart
index 93cc20c..f9300a1 100644
--- a/lib/src/payments/p2wpkh.dart
+++ b/lib/src/payments/p2wpkh.dart
@@ -4,19 +4,22 @@ import 'package:bip32/src/utils/ecurve.dart' show isPoint;
 import 'package:bech32/bech32.dart';
 
 import '../crypto.dart';
-import '../models/networks.dart';
+import 'package:bitcoin_flutter/src/models/networks.dart';
 import '../payments/index.dart' show PaymentData;
 import '../utils/script.dart' as bscript;
 import '../utils/constants/op.dart';
 
 class P2WPKH {
   final EMPTY_SCRIPT = Uint8List.fromList([]);
+  final OP = OPS['OP_0'];
+  final version = 0;
+  final length = 22;
 
   PaymentData data;
   NetworkType network;
   P2WPKH({@required data, network})
-  : this.network = network ?? bitcoin,
-    this.data = data {
+      : this.network = network ?? bitcoin,
+        this.data = data {
     _init();
   }
 
@@ -36,9 +39,9 @@ class P2WPKH {
     }
 
     if (data.output != null) {
-      if (data.output!.length != 22 ||
-          data.output![0] != OPS['OP_0'] ||
-          data.output![1] != 20) // 0x14
+      if (data.output!.length != length ||
+          data.output![0] != OP ||
+          (version == 0 ? data.output![1] != 20 : false)) // 0x14
         throw new ArgumentError('Output is invalid');
       if (data.hash == null) {
         data.hash = data.output!.sublist(2);
@@ -52,12 +55,10 @@ class P2WPKH {
     }
 
     if (data.witness != null) {
-      if (data.witness!.length != 2)
-        throw new ArgumentError('Witness is invalid');
+      if (data.witness!.length != 2) throw new ArgumentError('Witness is invalid');
       if (!bscript.isCanonicalScriptSignature(data.witness![0]))
         throw new ArgumentError('Witness has invalid signature');
-      if (!isPoint(data.witness![1]))
-        throw new ArgumentError('Witness has invalid pubkey');
+      if (!isPoint(data.witness![1])) throw new ArgumentError('Witness has invalid pubkey');
       _getDataFromWitness(data.witness!);
     } else if (data.pubkey != null && data.signature != null) {
       data.witness = [data.signature!, data.pubkey!];
@@ -81,10 +82,11 @@ class P2WPKH {
 
   void _getDataFromHash() {
     if (data.address == null) {
-      data.address = segwit.encode(Segwit(network.bech32, 0, data.hash!));
+      data.address =
+          segwit.encode(Segwit(network.bech32, version, data.hash!), isBech32m: version == 1);
     }
     if (data.output == null) {
-      data.output = bscript.compile([OPS['OP_0'], data.hash]);
+      data.output = bscript.compile([OP, data.hash]);
     }
   }
 
@@ -93,8 +95,7 @@ class P2WPKH {
       Segwit _address = segwit.decode(address);
       if (network.bech32 != _address.hrp)
         throw new ArgumentError('Invalid prefix or Network mismatch');
-      if (_address.version != 0) // Only support version 0 now;
-        throw new ArgumentError('Invalid address version');
+      if (_address.version != version) throw new ArgumentError('Invalid address version');
       data.hash = Uint8List.fromList(_address.program);
     } on InvalidHrp {
       throw new ArgumentError('Invalid prefix or Network mismatch');
@@ -105,3 +106,14 @@ class P2WPKH {
     }
   }
 }
+
+class P2TR extends P2WPKH {
+  @override
+  final OP = OPS['OP_1'];
+  @override
+  final version = 1;
+  @override
+  final length = 34;
+
+  P2TR({@required data, network}) : super(data: data, network: network);
+}
diff --git a/lib/src/payments/scanning.dart b/lib/src/payments/scanning.dart
new file mode 100644
index 0000000..e1e8408
--- /dev/null
+++ b/lib/src/payments/scanning.dart
@@ -0,0 +1,136 @@
+import 'dart:typed_data';
+import 'package:bitcoin_flutter/src/utils/int.dart';
+import 'package:bitcoin_flutter/src/utils/string.dart';
+import 'package:elliptic/elliptic.dart';
+import 'package:crypto/crypto.dart';
+import '../utils/uint8list.dart';
+
+// https://github.com/bitcoin/bips/blob/c55f80c53c98642357712c1839cfdc0551d531c4/bip-0352.mediawiki#scanning
+// https://github.com/bitcoin-core-review-club/bips/blob/cfe0771a0408a2d2de278d4e95bb9a33bd1615b2/bip-0352/reference.py#L105
+
+// RETURNS: [{output: [tweak, label]}]
+// Maps the output pubkey to the tweak used for the shared secret, and the label used to derive the tweak if applicable
+Map<String, List<String>> scanOutputs(PrivateKey b_scan, PublicKey B_spend, PublicKey A_sum,
+    Uint8List outpointsHash, List<Uint8List> outputPubKeys,
+    {Map<String, String>? labels}) {
+  final curve = getSecp256k1();
+
+  // - Let ecdh_shared_secret = outpoints_hash·b_scan·A
+  final tweakDataForRecipient = PublicKey.fromPoint(curve, A_sum).tweakMul(outpointsHash.bigint);
+  final ecdhSharedSecret = tweakDataForRecipient!.tweakMul(b_scan.D);
+
+  // P_k to priv key tweak matches
+  final matches = <String, List<String>>{};
+
+  // - Starting with k = 0:
+  var k = 0;
+
+  do {
+    // - Let t_k = sha256(serP(ecdh_shared_secret) || ser32(k))
+    final t_k = sha256
+        .convert(ecdhSharedSecret!.toCompressedHex().fromHex.concat([k.toBigEndianBytes]))
+        .toString()
+        .fromHex;
+
+    // - Compute P_k = B_spend + t_k·G
+    final P_k = PublicKey.fromPoint(curve, B_spend).tweakAdd(t_k.bigint).toCompressedHex().fromHex;
+    final length = outputPubKeys.length;
+
+    // - For each output in outputPubKeys
+    for (var i = 0; i < length; i++) {
+      final output = outputPubKeys[i];
+
+      // - If P_k equals output
+      if (output.sublist(1) != P_k.sublist(1)
+          ? output.hex == P_k.sublist(1).hex
+          : output.sublist(1).hex == P_k.sublist(1).hex) {
+        // - Add P_k to the wallet
+        matches[output.hex] = [t_k.hex];
+        outputPubKeys.removeAt(i);
+        k++; // Increment counter
+        break;
+      }
+
+      // - Else, if the wallet has precomputed labels (including the change label, if used)
+      if (labels != null && labels.isNotEmpty) {
+        final outputPubkey = PublicKey.fromBytes(curve, output);
+
+        // - Compute m·G = output - Pk
+        // m·G = output + (-P_k)
+        final negatedP_k = PublicKey.fromBytes(curve, P_k).negate();
+        var m_G_sub = PublicKey.fromPoint(curve, outputPubkey)
+            .pubkeyAdd(negatedP_k)
+            .toCompressedHex()
+            .fromHex;
+
+        // - Check if m·G exists in the list of labels used by the wallet
+        var m_G = labels[m_G_sub.hex];
+
+        // - If the label is not found, negate output and check again
+        if (m_G == null) {
+          outputPubkey.negate();
+          m_G_sub = PublicKey.fromPoint(curve, outputPubkey)
+              .pubkeyAdd(negatedP_k)
+              .toCompressedHex()
+              .fromHex;
+
+          m_G = labels[m_G_sub.hex];
+        }
+
+        // - If a match is found:
+        if (m_G != null) {
+          //  - Add the P_k + m·G to the wallet
+          final P_km = PublicKey.fromBytes(curve, P_k)
+              .tweakAdd(m_G.fromHex.bigint)
+              .toCompressedHex()
+              .fromHex;
+
+          if (P_km[0] == 0x03) {
+            P_km[0] = 0x02;
+          }
+
+          matches[output.hex] = [
+            PrivateKey.fromBytes(curve, t_k).tweakAdd(m_G.fromHex.bigint)!.toCompressedHex(),
+            m_G
+          ];
+
+          outputPubKeys.removeAt(i);
+          k++; // Increment counter
+          break;
+        } else {
+          final found = labels.values.any((tweak) {
+            final B_m = PublicKey.fromPoint(curve, B_spend).tweakAdd(tweak.fromHex.bigint);
+            final P_km =
+                PublicKey.fromPoint(curve, B_m).tweakAdd(t_k.bigint).toCompressedHex().fromHex;
+
+            if (output.sublist(1) != P_km.sublist(1)
+                ? output.hex == P_km.sublist(1).hex
+                : output.sublist(1).hex == P_km.sublist(1).hex) {
+              // - Add P_km to the wallet
+              matches[output.hex] = [
+                PrivateKey.fromBytes(curve, t_k).tweakAdd(tweak.fromHex.bigint)!.toCompressedHex(),
+                tweak
+              ];
+              outputPubKeys.removeAt(i);
+              k++; // Increment counter
+              return true;
+            }
+            return false;
+          });
+
+          if (found) {
+            break;
+          }
+        }
+      }
+
+      outputPubKeys.removeAt(i);
+
+      if (i + 1 >= outputPubKeys.length) {
+        break;
+      }
+    }
+  } while (outputPubKeys.isNotEmpty);
+
+  return matches;
+}
diff --git a/lib/src/payments/script/script.dart b/lib/src/payments/script/script.dart
new file mode 100644
index 0000000..437a3b2
--- /dev/null
+++ b/lib/src/payments/script/script.dart
@@ -0,0 +1,165 @@
+import 'dart:typed_data';
+
+import '../address/address.dart';
+import '../constants/constants.dart';
+import '../tools/tools.dart';
+import '../../crypto.dart';
+import '../../formatting/bytes_num_formatting.dart';
+import '../../formatting/bytes_tracker.dart';
+
+enum ScriptType { P2PKH, P2SH, P2WPKH, P2WSH, P2PK }
+
+/// A Script contains just a list of OP_CODES and also knows how to serialize into bytes
+///
+/// [script] the list with all the script OP_CODES and data
+class Script {
+  Script({required List<dynamic> script}) {
+    if (script is List<String>) {
+      this.script = script;
+      return;
+    }
+
+    final List<String> parsedScript = [];
+
+    for (final token in script) {
+      if (token is OP_WORDS) {
+        parsedScript.add(token.name);
+      } else if (token is String) {
+        parsedScript.add(token);
+      } else {
+        throw ArgumentError("Invalid script");
+      }
+    }
+
+    this.script = parsedScript;
+  }
+
+  late final List<String> script;
+
+  Uint8List toTapleafTaggedHash() {
+    final leafVarBytes = Uint8List.fromList([
+      ...Uint8List.fromList([LEAF_VERSION_TAPSCRIPT]),
+      ...prependVarint(toBytes())
+    ]);
+    return taggedHash(leafVarBytes, "TapLeaf");
+  }
+
+  /// create p2psh script wit current script
+  Script toP2shScriptPubKey() {
+    final address = P2shAddress(scriptPubKey: this);
+    return Script(script: ['OP_HASH160', address.h160, 'OP_EQUAL']);
+  }
+
+  static Script fromRaw({Uint8List? byteData, String? hexData, bool hasSegwit = false}) {
+    List<String> commands = [];
+    int index = 0;
+    final scriptraw = byteData ?? (hexData != null ? hexToBytes(hexData) : null);
+    if (scriptraw == null) {
+      throw ArgumentError("Invalid script");
+    }
+    while (index < scriptraw.length) {
+      int byte = scriptraw[index];
+      if (CODE_OPS.containsKey(byte)) {
+        commands.add(CODE_OPS[byte]!);
+        index = index + 1;
+      } else if (!hasSegwit && byte == 0x4c) {
+        int bytesToRead = scriptraw[index + 1];
+        index = index + 1;
+        commands.add(scriptraw
+            .sublist(index, index + bytesToRead)
+            .map((b) => b.toRadixString(16).padLeft(2, '0'))
+            .join());
+        index = index + bytesToRead;
+      } else if (!hasSegwit && byte == 0x4d) {
+        int bytesToRead =
+            ByteData.sublistView(scriptraw, index + 1, index + 3).getUint16(0, Endian.little);
+        index = index + 3;
+        commands.add(scriptraw
+            .sublist(index, index + bytesToRead)
+            .map((b) => b.toRadixString(16).padLeft(2, '0'))
+            .join());
+        index = index + bytesToRead;
+      } else if (!hasSegwit && byte == 0x4e) {
+        int bytesToRead =
+            ByteData.sublistView(scriptraw, index + 1, index + 5).getUint32(0, Endian.little);
+        index = index + 5;
+        commands.add(scriptraw
+            .sublist(index, index + bytesToRead)
+            .map((b) => b.toRadixString(16).padLeft(2, '0'))
+            .join());
+        index = index + bytesToRead;
+      } else {
+        try {
+          final viAndSize = viToInt(scriptraw.sublist(index, index + 9));
+          int dataSize = viAndSize.$1;
+          int size = viAndSize.$2;
+          final lastIndex = (index + size + dataSize) > scriptraw.length
+              ? scriptraw.length
+              : (index + size + dataSize);
+          commands.add(bytesToHex(scriptraw.sublist(index + size, lastIndex)));
+          index = index + dataSize + size;
+        } catch (_) {
+          throw ArgumentError("Input is invalid");
+        }
+      }
+    }
+    return Script(script: commands);
+  }
+
+  static ScriptType? getType({required String hexData, bool hasSegwit = false}) {
+    final Script s = fromRaw(hexData: hexData, hasSegwit: hasSegwit);
+    if (s.script.isEmpty) return null;
+    final first = s.script.elementAtOrNull(0);
+    final sec = s.script.elementAtOrNull(1);
+    final th = s.script.elementAtOrNull(2);
+    final four = s.script.elementAtOrNull(3);
+    final five = s.script.elementAtOrNull(4);
+    if (first == "OP_0") {
+      if (sec?.length == 40) {
+        return ScriptType.P2WPKH;
+      } else if (sec?.length == 64) {
+        return ScriptType.P2WSH;
+      }
+    } else if (first == "OP_DUP") {
+      if (sec == "OP_HASH160" && four == "OP_EQUALVERIFY" && five == "OP_CHECKSIG") {
+        return ScriptType.P2PKH;
+      }
+    } else if (first == "OP_HASH160" && th == "OP_EQUAL") {
+      return ScriptType.P2SH;
+    } else if (sec == "OP_CHECKSIG" && first is String) {
+      if (first.length == 66) {
+        return ScriptType.P2PK;
+      }
+    }
+    return null;
+  }
+
+  /// returns a serialized byte version of the script
+  Uint8List toBytes() {
+    DynamicByteTracker scriptBytes = DynamicByteTracker();
+    try {
+      for (var token in script) {
+        if (OP_CODES.containsKey(token)) {
+          scriptBytes.add(OP_CODES[token]!);
+        } else {
+          scriptBytes.add(opPushData(token));
+        }
+      }
+
+      return scriptBytes.toBytes();
+    } finally {
+      scriptBytes.close();
+    }
+  }
+
+  /// returns a serialized version of the script in hex
+  String toHex() {
+    final bytes = toBytes();
+    return bytesToHex(bytes);
+  }
+
+  @override
+  String toString() {
+    return script.join(" ");
+  }
+}
diff --git a/lib/src/payments/silentpayments.dart b/lib/src/payments/silentpayments.dart
new file mode 100644
index 0000000..e5cd530
--- /dev/null
+++ b/lib/src/payments/silentpayments.dart
@@ -0,0 +1,122 @@
+import 'dart:typed_data';
+
+import 'package:bitcoin_flutter/src/templates/outpoint.dart';
+import 'package:bitcoin_flutter/src/utils/int.dart';
+import 'package:bitcoin_flutter/src/utils/keys.dart';
+import 'package:bitcoin_flutter/src/utils/string.dart';
+import 'package:crypto/crypto.dart';
+import 'package:bitcoin_flutter/src/templates/silentpaymentaddress.dart';
+import 'package:bitcoin_flutter/src/utils/uint8list.dart';
+import 'package:elliptic/elliptic.dart';
+
+class SilentPayment {
+  SilentPayment();
+
+  static List<Outpoint> decodeOutpoints(List<(String, int)> outpoints) =>
+      outpoints.map((e) => Outpoint(txid: e.$1, index: e.$2)).toList();
+
+  // https://github.com/bitcoin/bips/blob/c55f80c53c98642357712c1839cfdc0551d531c4/bip-0352.mediawiki#outpoints-hash
+  // - The sender and receiver MUST calculate an outpoints hash for the transaction in the following manner:
+  static Uint8List hashOutpoints(List<Outpoint> sendingData) {
+    final outpoints = <Uint8List>[];
+
+    // - Collect each outpoint used as an input to the transaction
+    for (final outpoint in sendingData) {
+      final bytes = outpoint.txid.fromHex;
+      final vout = outpoint.index;
+
+      outpoints.add(concatenateUint8Lists(
+          [Uint8List.fromList(bytes.reversed.toList()), vout.toLittleEndianBytes]));
+    }
+
+    // - Let outpoints = outpoint_0 || ... || outpoint_n, sorted lexicographically by txid and vout, ascending order
+    outpoints.sort((a, b) => a.compare(b));
+
+    // - Let outpoints_hash = sha256(outpoints)
+    return Uint8List.fromList(sha256.convert(concatenateUint8Lists(outpoints)).bytes);
+  }
+
+  // https://github.com/bitcoin/bips/blob/c55f80c53c98642357712c1839cfdc0551d531c4/bip-0352.mediawiki#creating-outputs
+  static Map<String, List<(PublicKey, int)>> generateMultipleRecipientPubkeys(
+      List<PrivateKeyInfo> inputPrivKeyInfos,
+      Uint8List outpointsHash,
+      List<SilentPaymentDestination> silentPaymentDestinations) {
+    final curve = getSecp256k1();
+
+    // - Let a_sum = a_0 + a_1 + ... + a_n, where each a_i has been negated if necessary
+    PrivateKey? a_sum;
+    PublicKey? A_sum;
+
+    // - Collect the private keys for each input from the Inputs For Shared Secret Derivation list
+    for (final info in inputPrivKeyInfos) {
+      final key = info.key;
+      final isTaproot = info.isTaproot;
+
+      PrivateKey? negated;
+
+      // - For each private key a_i corresponding to a BIP341 taproot output, check that the private key produces a point with an even y-value and negate the private key if not
+      if (isTaproot && key.toCompressedHex().fromHex[0] == 0x03) {
+        negated = PrivateKey(curve, key.D).negate()!;
+      } else {
+        negated = PrivateKey(curve, key.D);
+      }
+
+      if (a_sum == null) {
+        a_sum = negated;
+        A_sum = negated.publicKey;
+      } else {
+        a_sum = a_sum.tweakAdd(negated.D);
+        A_sum!.pubkeyAdd(negated.publicKey);
+      }
+    }
+
+    // Group each destination by a different ecdhSharedSecret
+    // { <scanPubKey>: (<ecdhSharedSecret>, [<silentPaymentDestination1>, <silentPaymentDestination2>...]) }
+    Map<String, (PublicKey, List<SilentPaymentDestination>)> silentPaymentGroups = {};
+
+    silentPaymentDestinations.forEach((silentPaymentDestination) {
+      final B_scan = silentPaymentDestination.scanPubkey;
+      final scanPubKeyStr = B_scan.toCompressedHex();
+
+      if (silentPaymentGroups.containsKey(scanPubKeyStr)) {
+        // Current key already in silentPaymentGroups, simply add up the new destination
+        // with the already calculated ecdhSharedSecret
+        final (ecdhSharedSecret, recipients) = silentPaymentGroups[scanPubKeyStr]!;
+        silentPaymentGroups[scanPubKeyStr] =
+            (ecdhSharedSecret, [...recipients, silentPaymentDestination]);
+      } else {
+        // New silent payment destination, calculate a new ecdhSharedSecret
+        final senderPartialSecret = PrivateKey(curve, a_sum!.D).tweakMul(outpointsHash.bigint)!.D;
+        final ecdhSharedSecret = PublicKey.fromPoint(curve, B_scan).tweakMul(senderPartialSecret)!;
+
+        silentPaymentGroups[scanPubKeyStr] = (ecdhSharedSecret, [silentPaymentDestination]);
+      }
+    });
+
+    // Result destinations with amounts
+    // { <silentPaymentAddress>: [(<tweakedPubKey1>, <amount>), (<tweakedPubKey2>, <amount>)...] }
+    Map<String, List<(PublicKey, int)>> result = {};
+    silentPaymentGroups.entries.forEach((group) {
+      final (ecdhSharedSecret, destinations) = group.value;
+
+      int k = 0;
+      destinations.forEach((destination) {
+        final t_k =
+            sha256.convert(ecdhSharedSecret.toCompressedHex().fromHex.concat([k.toBigEndianBytes]));
+
+        final P_mn = PublicKey.fromPoint(curve, destination.spendPubkey)
+            .tweakAdd(Uint8List.fromList(t_k.bytes).bigint);
+
+        if (result.containsKey(destination.toString())) {
+          result[destination.toString()]!.add((P_mn, destination.amount));
+        } else {
+          result[destination.toString()] = [(P_mn, destination.amount)];
+        }
+
+        k++;
+      });
+    });
+
+    return result;
+  }
+}
diff --git a/lib/src/payments/tools/tools.dart b/lib/src/payments/tools/tools.dart
new file mode 100644
index 0000000..b9df2ec
--- /dev/null
+++ b/lib/src/payments/tools/tools.dart
@@ -0,0 +1,98 @@
+import 'dart:typed_data';
+import '../../payments/address/core.dart';
+import 'package:bitcoin_flutter/src/models/networks.dart';
+import '../../formatting/bytes_num_formatting.dart';
+import 'package:convert/convert.dart';
+import 'package:bs58check/bs58check.dart' as bs58check;
+
+bool isValidAddress(String address, AddressType type, {NetworkType? network}) {
+  if (address.length < 26 || address.length > 35) {
+    return false;
+  }
+  final decode = bs58check.decode(address);
+  final int networkPrefix = decode[0];
+  switch (type) {
+    case AddressType.p2pkh:
+      if (network != null && networkPrefix != network.p2pkhPrefix) {
+        throw new ArgumentError('Invalid version or Network mismatch');
+      }
+
+      if (networkPrefix != NetworkType.BITCOIN.p2pkhPrefix &&
+          networkPrefix != NetworkType.TESTNET.p2pkhPrefix)
+        throw new ArgumentError('Invalid version or Network mismatch');
+
+      if (decode.sublist(1).length != 20) throw ArgumentError("Invalid address");
+    case AddressType.p2pkhInP2sh:
+    case AddressType.p2pkInP2sh:
+    case AddressType.p2wshInP2sh:
+    case AddressType.p2wpkhInP2sh:
+      if (network != null && networkPrefix != network.p2pkhPrefix) {
+        throw new ArgumentError('Invalid version or Network mismatch');
+      }
+      return networkPrefix == NetworkType.BITCOIN.p2shPrefix ||
+          networkPrefix == NetworkType.TESTNET.p2shPrefix;
+    default:
+  }
+  return true;
+}
+
+bool isValidHash160(String hash160) {
+  if (hash160.length != 40) {
+    return false;
+  }
+  try {
+    BigInt.parse(hash160, radix: 16);
+  } catch (e) {
+    return false;
+  }
+  return true;
+}
+
+List<int> opPushData(String hexData) {
+  final Uint8List dataBytes = hexToBytes(hexData);
+  if (dataBytes.length < 0x4c) {
+    return Uint8List.fromList([dataBytes.length]) + dataBytes;
+  } else if (dataBytes.length < 0xff) {
+    return Uint8List.fromList([0x4c]) + Uint8List.fromList([dataBytes.length]) + dataBytes;
+  } else if (dataBytes.length < 0xffff) {
+    var lengthBytes = ByteData(2);
+    lengthBytes.setUint16(0, dataBytes.length, Endian.little);
+    return Uint8List.fromList([0x4d]) + Uint8List.view(lengthBytes.buffer) + dataBytes;
+  } else if (dataBytes.length < 0xffffffff) {
+    var lengthBytes = ByteData(4);
+    lengthBytes.setUint32(0, dataBytes.length, Endian.little);
+    return Uint8List.fromList([0x4e]) + Uint8List.view(lengthBytes.buffer) + dataBytes;
+  } else {
+    throw ArgumentError("Data too large. Cannot push into script");
+  }
+}
+
+Uint8List pushInteger(int integer) {
+  if (integer < 0) {
+    throw ArgumentError('Integer is currently required to be positive.');
+  }
+
+  /// Calculate the number of bytes required to represent the integer
+  int numberOfBytes = (integer.bitLength + 7) ~/ 8;
+
+  /// Convert to little-endian bytes
+  Uint8List integerBytes = Uint8List(numberOfBytes);
+  for (int i = 0; i < numberOfBytes; i++) {
+    integerBytes[i] = (integer >> (i * 8)) & 0xFF;
+  }
+
+  /// If the last bit is set, add a sign byte to signify a positive integer
+  if ((integer & (1 << (numberOfBytes * 8 - 1))) != 0) {
+    integerBytes = Uint8List.fromList([...integerBytes, 0x00]);
+  }
+
+  return Uint8List.fromList(opPushData(hex.encode(integerBytes)));
+}
+
+Uint8List bytes32FromInt(int x) {
+  var result = Uint8List(32);
+  for (var i = 0; i < 32; i++) {
+    result[32 - i - 1] = (x >> (8 * i)) & 0xFF;
+  }
+  return result;
+}
diff --git a/lib/src/templates/outpoint.dart b/lib/src/templates/outpoint.dart
new file mode 100644
index 0000000..693cf21
--- /dev/null
+++ b/lib/src/templates/outpoint.dart
@@ -0,0 +1,19 @@
+import 'dart:typed_data';
+
+import 'package:bitcoin_flutter/bitcoin_flutter.dart';
+
+class Outpoint {
+  Outpoint({required this.txid, required this.index, this.value});
+
+  String txid;
+  int index;
+  int? value;
+
+  factory Outpoint.fromBytes(Uint8List txid, int index, {int? value}) {
+    return Outpoint(txid: txid.hex, index: index, value: value);
+  }
+
+  String toString() {
+    return 'Outpoint{txid: $txid, index: $index, value: $value}';
+  }
+}
diff --git a/lib/src/templates/pubkeyhash.dart b/lib/src/templates/pubkeyhash.dart
deleted file mode 100644
index 88af094..0000000
--- a/lib/src/templates/pubkeyhash.dart
+++ /dev/null
@@ -1,20 +0,0 @@
-import 'dart:typed_data';
-import '../utils/script.dart' as bscript;
-import '../utils/constants/op.dart';
-
-bool inputCheck(List<dynamic> chunks) {
-  return chunks != null &&
-      chunks.length == 2 &&
-      bscript.isCanonicalScriptSignature(chunks[0]) &&
-      bscript.isCanonicalPubKey(chunks[1]);
-}
-
-bool outputCheck(Uint8List script) {
-  final buffer = bscript.compile(script);
-  return buffer.length == 25 &&
-      buffer[0] == OPS['OP_DUP'] &&
-      buffer[1] == OPS['OP_HASH160'] &&
-      buffer[2] == 0x14 &&
-      buffer[23] == OPS['OP_EQUALVERIFY'] &&
-      buffer[24] == OPS['OP_CHECKSIG'];
-}
diff --git a/lib/src/templates/silentpaymentaddress.dart b/lib/src/templates/silentpaymentaddress.dart
new file mode 100644
index 0000000..1d8094b
--- /dev/null
+++ b/lib/src/templates/silentpaymentaddress.dart
@@ -0,0 +1,188 @@
+import 'dart:typed_data';
+
+import '../bitcoin_flutter_base.dart';
+import '../utils/constants/derivation_paths.dart';
+import '../utils/string.dart';
+import '../utils/uint8list.dart';
+import 'package:elliptic/elliptic.dart';
+import 'package:bech32/bech32.dart';
+import 'package:bip32/bip32.dart' as bip32;
+import 'package:bip39/bip39.dart' as bip39;
+
+class SilentPaymentReceiver extends SilentPaymentAddress {
+  late int version;
+  late PublicKey scanPubkey;
+  late PublicKey spendPubkey;
+  late String hrp;
+
+  late PrivateKey scanPrivkey;
+  late PrivateKey spendPrivkey;
+
+  SilentPaymentReceiver({
+    required this.version,
+    required this.scanPubkey,
+    required this.spendPubkey,
+    required this.hrp,
+    required this.scanPrivkey,
+    required this.spendPrivkey,
+  }) : super(
+          version: version,
+          scanPubkey: scanPubkey,
+          spendPubkey: spendPubkey,
+          hrp: hrp,
+        );
+
+  factory SilentPaymentReceiver.fromPrivKeys(
+      {required PrivateKey scanPrivkey, required spendPrivkey, String? hrp, int? version}) {
+    return SilentPaymentReceiver(
+      scanPrivkey: scanPrivkey,
+      spendPrivkey: spendPrivkey,
+      scanPubkey: scanPrivkey.publicKey,
+      spendPubkey: spendPrivkey.publicKey,
+      hrp: hrp ?? 'sp',
+      version: version ?? 0,
+    );
+  }
+
+  factory SilentPaymentReceiver.fromHd(HDWallet hd, {String? hrp, int? version}) {
+    final scanPubkey = hd.derivePath(SCAN_PATH);
+    final spendPubkey = hd.derivePath(SPEND_PATH);
+
+    final curve = getSecp256k1();
+
+    return SilentPaymentReceiver(
+      scanPrivkey: PrivateKey.fromBytes(curve, scanPubkey.privKey!.fromHex),
+      spendPrivkey: PrivateKey.fromBytes(curve, spendPubkey.privKey!.fromHex),
+      scanPubkey: PublicKey.fromHex(curve, scanPubkey.pubKey!),
+      spendPubkey: PublicKey.fromHex(curve, spendPubkey.pubKey!),
+      hrp: hrp ?? 'sp',
+      version: version ?? 0,
+    );
+  }
+
+  factory SilentPaymentReceiver.fromMnemonic(String mnemonic, {String? hrp, int? version}) {
+    final seed = bip39.mnemonicToSeed(mnemonic);
+    final root = bip32.BIP32.fromSeed(
+        seed,
+        hrp == "tsp"
+            ? bip32.NetworkType(
+                wif: 0xef, bip32: new bip32.Bip32Type(public: 0x043587cf, private: 0x04358394))
+            : null);
+    if (root.depth != 0 || root.parentFingerprint != 0) throw new ArgumentError('Bad master key!');
+
+    final scanPubkey = root.derivePath(SCAN_PATH);
+    final spendPubkey = root.derivePath(SPEND_PATH);
+
+    final curve = getSecp256k1();
+
+    return SilentPaymentReceiver(
+      scanPrivkey: PrivateKey.fromBytes(curve, scanPubkey.privateKey!),
+      spendPrivkey: PrivateKey.fromBytes(curve, spendPubkey.privateKey!),
+      scanPubkey: PublicKey.fromHex(curve, scanPubkey.publicKey.hex),
+      spendPubkey: PublicKey.fromHex(curve, spendPubkey.publicKey.hex),
+      hrp: hrp ?? 'sp',
+      version: version ?? 0,
+    );
+  }
+}
+
+class SilentPaymentDestination extends SilentPaymentAddress {
+  SilentPaymentDestination({
+    required int version,
+    required PublicKey scanPubkey,
+    required PublicKey spendPubkey,
+    required String hrp,
+    required this.amount,
+  }) : super(version: version, scanPubkey: scanPubkey, spendPubkey: spendPubkey, hrp: hrp);
+
+  int amount;
+
+  factory SilentPaymentDestination.fromAddress(String address, int amount) {
+    final receiver = SilentPaymentAddress.fromString(address);
+
+    return SilentPaymentDestination(
+      scanPubkey: receiver.scanPubkey,
+      spendPubkey: receiver.spendPubkey,
+      hrp: receiver.hrp,
+      version: receiver.version,
+      amount: amount,
+    );
+  }
+}
+
+class SilentPaymentAddress {
+  static RegExp get REGEX => RegExp(r'(^|\s)t?sp1[0-9a-zA-Z]{113}($|\s)');
+
+  int version;
+  PublicKey scanPubkey;
+  PublicKey spendPubkey;
+  // human readable part (sprt, sp, tsp)
+  String hrp;
+
+  SilentPaymentAddress({
+    required this.version,
+    required this.scanPubkey,
+    required this.spendPubkey,
+    required this.hrp,
+  }) {
+    if (version != 0) {
+      throw Exception("Can't have other version than 0 for now");
+    }
+  }
+
+  factory SilentPaymentAddress.fromString(String address) {
+    final decoded = bech32m.decode(address, 1023);
+
+    final prefix = decoded.hrp;
+    if (prefix != 'sp' && prefix != 'sprt' && prefix != 'tsp') {
+      throw Exception('Invalid prefix: $prefix');
+    }
+
+    final words = decoded.data;
+    final version = words[0];
+    if (version != 0) throw new ArgumentError('Invalid version');
+
+    final key = fromWords(Uint8List.fromList(decoded.data.sublist(1)));
+    final curve = getSecp256k1();
+
+    return SilentPaymentAddress(
+      scanPubkey: PublicKey.fromHex(curve, key.sublist(0, 33).hex),
+      spendPubkey: PublicKey.fromHex(curve, key.sublist(33).hex),
+      hrp: prefix,
+      version: version,
+    );
+  }
+
+  factory SilentPaymentAddress.createLabeledSilentPaymentAddress(
+      PublicKey B_scan, PublicKey B_spend, Uint8List m,
+      {String hrp = 'sp', int version = 0}) {
+    final B_m = PublicKey.fromPoint(getSecp256k1(), B_spend).tweakAdd(m.bigint);
+    return SilentPaymentAddress(scanPubkey: B_scan, spendPubkey: B_m, hrp: hrp, version: version);
+  }
+
+  @override
+  String toString() {
+    final data = toWords(Uint8List.fromList(
+        [...scanPubkey.toCompressedHex().fromHex, ...spendPubkey.toCompressedHex().fromHex]));
+    final versionData = Uint8List.fromList([Bech32U5(version).value, ...data]);
+
+    return bech32m.encode(Bech32(hrp, versionData), 1023);
+  }
+}
+
+class Bech32U5 {
+  final int value;
+
+  Bech32U5(this.value) {
+    if (value < 0 || value > 31) {
+      throw Exception('Value is outside the valid range.');
+    }
+  }
+
+  static Bech32U5 tryFromInt(int value) {
+    if (value < 0 || value > 31) {
+      throw Exception('Value is outside the valid range.');
+    }
+    return Bech32U5(value);
+  }
+}
diff --git a/lib/src/templates/witnesspubkeyhash.dart b/lib/src/templates/witnesspubkeyhash.dart
index ec660d7..12765e0 100644
--- a/lib/src/templates/witnesspubkeyhash.dart
+++ b/lib/src/templates/witnesspubkeyhash.dart
@@ -13,3 +13,8 @@ bool outputCheck(Uint8List script) {
   final buffer = bscript.compile(script);
   return buffer.length == 22 && buffer[0] == OPS['OP_0'] && buffer[1] == 0x14;
 }
+
+bool taprootOutputCheck(Uint8List script) {
+  final buffer = bscript.compile(script);
+  return buffer[0] == OPS['OP_1'];
+}
diff --git a/lib/src/transaction.dart b/lib/src/transaction.dart
index 35794f6..2e89e99 100644
--- a/lib/src/transaction.dart
+++ b/lib/src/transaction.dart
@@ -1,40 +1,33 @@
 import 'dart:typed_data';
+import 'package:bitcoin_flutter/src/formatting/bytes_tracker.dart';
+import 'package:bitcoin_flutter/src/payments/address/address.dart';
+import 'package:bitcoin_flutter/src/payments/script/script.dart';
+import 'package:bitcoin_flutter/src/payments/constants/constants.dart';
+import 'package:bitcoin_flutter/src/utils/string.dart';
 import 'package:hex/hex.dart';
 import 'payments/index.dart' show PaymentData;
-import 'payments/p2pkh.dart' show P2PKH;
-import 'payments/p2pk.dart' show P2PK;
-import 'payments/p2wpkh.dart' show P2WPKH;
+import 'payments/p2wpkh.dart' show P2WPKH, P2TR;
 import 'crypto.dart' as bcrypto;
 import 'classify.dart';
 import 'utils/check_types.dart';
 import 'utils/script.dart' as bscript;
+import 'ecpair.dart' as ecpair;
 import 'utils/constants/op.dart';
 import 'utils/varuint.dart' as varuint;
+import 'utils/uint8list.dart';
 import 'package:collection/collection.dart';
+import 'formatting/bytes_num_formatting.dart';
 
-const DEFAULT_SEQUENCE = 0xffffffff;
-const SIGHASH_ALL = 0x01;
-const SIGHASH_NONE = 0x02;
-const SIGHASH_SINGLE = 0x03;
-const SIGHASH_ANYONECANPAY = 0x80;
-const ADVANCED_TRANSACTION_MARKER = 0x00;
-const ADVANCED_TRANSACTION_FLAG = 0x01;
-final EMPTY_SCRIPT = Uint8List.fromList([]);
-final EMPTY_WITNESS = <Uint8List>[];
-final ZERO = HEX
-    .decode('0000000000000000000000000000000000000000000000000000000000000000');
-final ONE = HEX
-    .decode('0000000000000000000000000000000000000000000000000000000000000001');
-final VALUE_UINT64_MAX = HEX.decode('ffffffffffffffff');
 final BLANK_OUTPUT =
     new Output(script: EMPTY_SCRIPT, valueBuffer: Uint8List.fromList(VALUE_UINT64_MAX));
 
 class Transaction {
   int version = 1;
+  String? txHex;
   int locktime = 0;
   List<Input> ins = [];
   List<Output> outs = [];
-  Transaction();
+  Transaction({int? version}) : this.version = version ?? 1;
 
   int addInput(Uint8List hash, int index, [int? sequence, Uint8List? scriptSig]) {
     ins.add(new Input(
@@ -52,8 +45,8 @@ class Transaction {
   }
 
   bool hasWitnesses() {
-    var witness = ins.firstWhereOrNull(
-        (input) => input.witness != null && input.witness!.length != 0);
+    var witness =
+        ins.firstWhereOrNull((input) => input.witness != null && input.witness!.length != 0);
     return witness != null;
   }
 
@@ -65,8 +58,7 @@ class Transaction {
     ins[index].witness = witness;
   }
 
-  hashForWitnessV0(
-      int inIndex, Uint8List prevOutScript, int value, int hashType) {
+  hashForWitnessV0(int inIndex, Uint8List prevOutScript, int value, int hashType) {
     var tbuffer = Uint8List.fromList([]);
     var toffset = 0;
     // Any changes made to the ByteData will also change the buffer, and vice versa.
@@ -142,10 +134,8 @@ class Transaction {
       hashSequence = bcrypto.hash256(tbuffer);
     }
 
-    if ((hashType & 0x1f) != SIGHASH_SINGLE &&
-        (hashType & 0x1f) != SIGHASH_NONE) {
-      var txOutsSize =
-          outs.fold<int>(0, (sum, output) => sum + 8 + varSliceSize(output.script!));
+    if ((hashType & 0x1f) != SIGHASH_SINGLE && (hashType & 0x1f) != SIGHASH_NONE) {
+      var txOutsSize = outs.fold<int>(0, (sum, output) => sum + 8 + varSliceSize(output.script!));
       tbuffer = new Uint8List(txOutsSize);
       bytes = tbuffer.buffer.asByteData();
       toffset = 0;
@@ -184,11 +174,121 @@ class Transaction {
     return bcrypto.hash256(tbuffer);
   }
 
+  hashForWitnessV1(int txIndex, Uint8List prevOutScript, int value, int hashType, List<int> amounts,
+      List<Uint8List> scriptPubKeys,
+      {int sighash = TAPROOT_SIGHASH_ALL}) {
+    bool sighashNone = (sighash & 0x03) == SIGHASH_NONE;
+    bool sighashSingle = (sighash & 0x03) == SIGHASH_SINGLE;
+    bool anyoneCanPay = (sighash & 0x80) == SIGHASH_ANYONECANPAY;
+    DynamicByteTracker txForSign = DynamicByteTracker();
+    txForSign.add([0]);
+    txForSign.add(Uint16List.fromList([sighash]));
+    txForSign.add([0x02, 0x00, 0x00, 0x00]);
+    txForSign.add([0x00, 0x00, 0x00, 0x00]);
+    Uint8List hashPrevouts = Uint8List(0);
+    Uint8List hashAmounts = Uint8List(0);
+    Uint8List hashScriptPubkeys = Uint8List(0);
+    Uint8List hashSequences = Uint8List(0);
+    Uint8List hashOutputs = Uint8List(0);
+    if (!anyoneCanPay) {
+      for (final txin in ins) {
+        Uint8List txidBytes = Uint8List.fromList(txin.hash!);
+
+        Uint8List txoutIndexBytes = packUint32LE(txin.index!);
+        hashPrevouts = Uint8List.fromList([...hashPrevouts, ...txidBytes, ...txoutIndexBytes]);
+
+        final h = txin.script!.hex;
+
+        /// must checked
+        int scriptLen = h.length ~/ 2;
+        Uint8List scriptBytes = hexToBytes(h);
+        Uint8List lenBytes = Uint8List.fromList([scriptLen]);
+        hashScriptPubkeys = Uint8List.fromList([...hashScriptPubkeys, ...lenBytes, ...scriptBytes]);
+
+        hashSequences = Uint8List.fromList([
+          ...hashSequences,
+          ...[0x00, 0x00, 0x00, 0x00]
+        ]);
+      }
+      hashPrevouts = bcrypto.singleHash(hashPrevouts);
+      txForSign.add(hashPrevouts);
+
+      for (final i in amounts) {
+        Uint8List bytes = packBigIntToLittleEndian(BigInt.from(i));
+        hashAmounts = Uint8List.fromList([...hashAmounts, ...bytes]);
+      }
+      txForSign.add(hashAmounts);
+
+      for (final s in scriptPubKeys) {
+        final h = s.hex;
+
+        /// must checked
+        int scriptLen = h.length ~/ 2;
+        Uint8List scriptBytes = hexToBytes(h);
+        Uint8List lenBytes = Uint8List.fromList([scriptLen]);
+        hashScriptPubkeys = Uint8List.fromList([...hashScriptPubkeys, ...lenBytes, ...scriptBytes]);
+      }
+      hashScriptPubkeys = bcrypto.singleHash(hashScriptPubkeys);
+      txForSign.add(hashScriptPubkeys);
+
+      hashSequences = bcrypto.singleHash(hashSequences);
+      txForSign.add(hashSequences);
+    }
+
+    if (!(sighashNone || sighashSingle)) {
+      for (final txOut in outs) {
+        Uint8List packedAmount = packBigIntToLittleEndian(BigInt.from(txOut.value!));
+        Uint8List scriptBytes = txOut.script!;
+        final lenScriptBytes = Uint8List.fromList([scriptBytes.length]);
+        hashOutputs = Uint8List.fromList(
+            [...hashOutputs, ...packedAmount, ...lenScriptBytes, ...scriptBytes]);
+      }
+      hashOutputs = bcrypto.singleHash(hashOutputs);
+      txForSign.add(hashOutputs);
+    }
+
+    final extFlags = 0;
+    final int spendType = extFlags * 2 + 0;
+    txForSign.add(Uint8List.fromList([spendType]));
+
+    int index = txIndex;
+    ByteData byteData = ByteData(4);
+    for (int i = 0; i < 4; i++) {
+      byteData.setUint8(i, index & 0xFF);
+      index >>= 8;
+    }
+    Uint8List bytes = byteData.buffer.asUint8List();
+    txForSign.add(bytes);
+
+    if (sighashSingle) {
+      final txOut = outs[txIndex];
+
+      Uint8List packedAmount = packBigIntToLittleEndian(BigInt.from(txOut.value!));
+      final sBytes = txOut.script!;
+      Uint8List lenScriptBytes = Uint8List.fromList([sBytes.length]);
+
+      final hashOut = Uint8List.fromList([...packedAmount, ...lenScriptBytes, ...sBytes]);
+      txForSign.add(bcrypto.singleHash(hashOut));
+    }
+    if (extFlags == 1) {
+      final leafVar = LEAF_VERSION_TAPSCRIPT;
+      final leafVarBytes = Uint8List.fromList([
+        ...Uint8List.fromList([leafVar]),
+        ...prependVarint(prevOutScript)
+      ]);
+      txForSign.add(bcrypto.taggedHash(leafVarBytes, "TapLeaf"));
+      txForSign.add(Uint16List.fromList([0]));
+      txForSign.add(Uint8List.fromList([0xFF, 0xFF, 0xFF, 0xFF]));
+    }
+    final signBytes = txForSign.toBytes();
+    txForSign.close();
+    return bcrypto.taggedHash(signBytes, "TapSighash");
+  }
+
   hashForSignature(int inIndex, Uint8List prevOutScript, int hashType) {
     if (inIndex >= ins.length) return ONE;
     // ignore OP_CODESEPARATOR
-    final ourScript =
-        bscript.compile(bscript.decompile(prevOutScript)!.where((x) {
+    final ourScript = bscript.compile(bscript.decompile(prevOutScript)!.where((x) {
       return x != OPS['OP_CODESEPARATOR'];
     }).toList());
     final txTmp = Transaction.clone(this);
@@ -236,9 +336,7 @@ class Transaction {
     }
     // serialize and hash
     final buffer = Uint8List(txTmp.virtualSize() + 4);
-    buffer.buffer
-        .asByteData()
-        .setUint32(buffer.length - 4, hashType, Endian.little);
+    buffer.buffer.asByteData().setUint32(buffer.length - 4, hashType, Endian.little);
     txTmp._toBuffer(buffer, 0);
     return bcrypto.hash256(buffer);
   }
@@ -251,7 +349,8 @@ class Transaction {
         ins.fold(0, (sum, input) => sum + 40 + varSliceSize(input.script!)) +
         outs.fold(0, (sum, output) => sum + 8 + varSliceSize(output.script!)) +
         (hasWitness
-            ? ins.fold(0, (sum, input) => sum + vectorSize(input.witness!))
+            ? ins.fold(
+                0, (sum, input) => input.witness != null ? (sum + vectorSize(input.witness!)) : 0)
             : 0);
   }
 
@@ -475,8 +574,7 @@ class Transaction {
     final flag = readUInt8();
 
     var hasWitnesses = false;
-    if (marker == ADVANCED_TRANSACTION_MARKER &&
-        flag == ADVANCED_TRANSACTION_FLAG) {
+    if (marker == ADVANCED_TRANSACTION_MARKER && flag == ADVANCED_TRANSACTION_FLAG) {
       hasWitnesses = true;
     } else {
       offset -= 2; // Reset offset if not segwit tx
@@ -506,8 +604,7 @@ class Transaction {
 
     if (noStrict) return tx;
 
-    if (offset != buffer.length)
-      throw new ArgumentError('Transaction has unexpected data');
+    if (offset != buffer.length) throw new ArgumentError('Transaction has unexpected data');
 
     return tx;
   }
@@ -547,6 +644,7 @@ class Input {
   List<Uint8List?>? pubkeys;
   List<Uint8List?>? signatures;
   List<Uint8List>? witness;
+  ecpair.ECPair? keyPair;
 
   Input(
       {this.hash,
@@ -558,7 +656,8 @@ class Input {
       this.pubkeys,
       this.signatures,
       this.witness,
-      this.prevOutType})
+      this.prevOutType,
+      this.keyPair})
       : this.hasWitness = false {
     if (this.hash != null && !isHash256bit(this.hash!))
       throw new ArgumentError('Invalid input hash');
@@ -566,12 +665,11 @@ class Input {
       throw new ArgumentError('Invalid input index');
     if (this.sequence != null && !isUint(this.sequence!, 32))
       throw new ArgumentError('Invalid input sequence');
-    if (this.value != null && !isShatoshi(this.value!))
-      throw ArgumentError('Invalid ouput value');
+    if (this.value != null && !isSatoshi(this.value!)) throw ArgumentError('Invalid ouput value');
   }
 
   factory Input.expandInput(Uint8List scriptSig, List<Uint8List> witness,
-      [String? type, Uint8List? scriptPubKey]) {
+      [String? type, Uint8List? scriptPubKey, ecpair.ECPair? keyPair, int? value]) {
     if (type == null || type == '') {
       String? ssType = classifyInput(scriptSig);
       String? wsType = classifyWitness(witness);
@@ -585,20 +683,27 @@ class Input {
           prevOutScript: p2wpkh.data.output,
           prevOutType: SCRIPT_TYPES['P2WPKH']!,
           pubkeys: [p2wpkh.data.pubkey!],
-          signatures: [p2wpkh.data.signature!]);
+          signatures: [p2wpkh.data.signature!],
+          keyPair: keyPair,
+          value: value);
+    } else if (type == SCRIPT_TYPES['P2TR']) {
+      P2TR p2tr = new P2TR(data: new PaymentData(witness: witness));
+      return new Input(
+          prevOutScript: p2tr.data.output,
+          prevOutType: SCRIPT_TYPES['P2TR']!,
+          pubkeys: [p2tr.data.pubkey!],
+          signatures: [p2tr.data.signature!],
+          keyPair: keyPair,
+          value: value);
     } else if (type == SCRIPT_TYPES['P2PKH']) {
-      P2PKH p2pkh = new P2PKH(data: new PaymentData(input: scriptSig));
+      final p2pkh = new P2pkhAddress(scriptSig: Script.fromRaw(byteData: scriptSig));
       return new Input(
-          prevOutScript: p2pkh.data.output,
+          prevOutScript: p2pkh.scriptPubkey.toBytes(),
           prevOutType: SCRIPT_TYPES['P2PKH']!,
-          pubkeys: [p2pkh.data.pubkey!],
-          signatures: [p2pkh.data.signature!]);
-    } else if (type == SCRIPT_TYPES['P2PK']) {
-      P2PK p2pk = new P2PK(data: new PaymentData(input: scriptSig));
-      return new Input(
-          prevOutType: SCRIPT_TYPES['P2PK']!,
-          pubkeys: [],
-          signatures: [p2pk.data.signature!]);
+          pubkeys: [p2pkh.pubkey!.fromHex],
+          signatures: [p2pkh.signature!.fromHex],
+          keyPair: keyPair,
+          value: value);
     }
     throw Exception('Cannot to build Input with expandInput factory');
   }
@@ -610,17 +715,15 @@ class Input {
       script: input.script != null ? Uint8List.fromList(input.script!) : null,
       sequence: input.sequence,
       value: input.value,
-      prevOutScript: input.prevOutScript != null
-          ? Uint8List.fromList(input.prevOutScript!)
-          : null,
+      prevOutScript: input.prevOutScript != null ? Uint8List.fromList(input.prevOutScript!) : null,
       pubkeys: input.pubkeys != null
-          ? input.pubkeys!.map(
-              (pubkey) => pubkey != null ? Uint8List.fromList(pubkey) : null)
+          ? input.pubkeys!
+              .map((pubkey) => pubkey != null ? Uint8List.fromList(pubkey) : null)
               .toList()
           : null,
       signatures: input.signatures != null
-          ? input.signatures!.map((signature) =>
-              signature != null ? Uint8List.fromList(signature) : null)
+          ? input.signatures!
+              .map((signature) => signature != null ? Uint8List.fromList(signature) : null)
               .toList()
           : null,
     );
@@ -639,28 +742,26 @@ class Output {
   List<Uint8List?>? pubkeys;
   List<Uint8List?>? signatures;
 
-  Output(
-      {this.script,
-      this.value,
-      this.pubkeys,
-      this.signatures,
-      this.valueBuffer}) {
-    if (value != null && !isShatoshi(value!))
-      throw ArgumentError('Invalid ouput value');
+  Output({this.script, this.value, this.pubkeys, this.signatures, this.valueBuffer}) {
+    if (value != null && !isSatoshi(value!)) throw ArgumentError('Invalid ouput value');
   }
 
   factory Output.expandOutput(Uint8List script, [Uint8List? ourPubKey]) {
     if (ourPubKey == null) return new Output();
     var type = classifyOutput(script);
     if (type == SCRIPT_TYPES['P2WPKH']) {
-      Uint8List wpkh1 =
-          new P2WPKH(data: new PaymentData(output: script)).data.hash!;
+      Uint8List wpkh1 = new P2WPKH(data: new PaymentData(output: script)).data.hash!;
+      Uint8List wpkh2 = bcrypto.hash160(ourPubKey);
+      if (wpkh1 != wpkh2) throw ArgumentError('Hash mismatch!');
+      return new Output(pubkeys: [ourPubKey], signatures: [null]);
+    } else if (type == SCRIPT_TYPES['P2TR']) {
+      Uint8List wpkh1 = new P2TR(data: new PaymentData(output: script)).data.hash!;
       Uint8List wpkh2 = bcrypto.hash160(ourPubKey);
       if (wpkh1 != wpkh2) throw ArgumentError('Hash mismatch!');
       return new Output(pubkeys: [ourPubKey], signatures: [null]);
     } else if (type == SCRIPT_TYPES['P2PKH']) {
       Uint8List pkh1 =
-          new P2PKH(data: new PaymentData(output: script)).data.hash!;
+          new P2pkhAddress(scriptPubKey: Script.fromRaw(byteData: script)).h160.fromHex;
       Uint8List pkh2 = bcrypto.hash160(ourPubKey);
       if (pkh1 != pkh2) throw ArgumentError('Hash mismatch!');
       return new Output(pubkeys: [ourPubKey], signatures: [null]);
@@ -672,17 +773,15 @@ class Output {
     return new Output(
       script: output.script != null ? Uint8List.fromList(output.script!) : null,
       value: output.value,
-      valueBuffer: output.valueBuffer != null
-          ? Uint8List.fromList(output.valueBuffer!)
-          : null,
+      valueBuffer: output.valueBuffer != null ? Uint8List.fromList(output.valueBuffer!) : null,
       pubkeys: output.pubkeys != null
-          ? output.pubkeys!.map(
-              (pubkey) => pubkey != null ? Uint8List.fromList(pubkey) : null)
+          ? output.pubkeys!
+              .map((pubkey) => pubkey != null ? Uint8List.fromList(pubkey) : null)
               .toList()
           : null,
       signatures: output.signatures != null
-          ? output.signatures!.map((signature) =>
-              signature != null ? Uint8List.fromList(signature) : null)
+          ? output.signatures!
+              .map((signature) => signature != null ? Uint8List.fromList(signature) : null)
               .toList()
           : null,
     );
diff --git a/lib/src/transaction_builder.dart b/lib/src/transaction_builder.dart
index d3f1064..8462f44 100644
--- a/lib/src/transaction_builder.dart
+++ b/lib/src/transaction_builder.dart
@@ -1,17 +1,16 @@
 import 'dart:convert';
 import 'dart:typed_data';
 import 'package:bitcoin_flutter/src/utils/constants/op.dart';
-import 'package:meta/meta.dart';
+import 'package:bitcoin_flutter/src/utils/uint8list.dart';
+import 'package:bitcoin_flutter/src/payments/address/address.dart';
+import 'package:bitcoin_flutter/src/payments/constants/constants.dart';
+import 'package:bitcoin_flutter/src/models/networks.dart';
+import 'package:bitcoin_flutter/src/address.dart';
 import 'package:hex/hex.dart';
-import 'package:bs58check/bs58check.dart' as bs58check;
-import 'package:bech32/bech32.dart';
 import 'utils/script.dart' as bscript;
-import 'ecpair.dart';
-import 'models/networks.dart';
+import 'ecpair.dart' as ecpair;
 import 'transaction.dart';
-import 'address.dart';
 import 'payments/index.dart' show PaymentData;
-import 'payments/p2pkh.dart';
 import 'payments/p2wpkh.dart';
 import 'classify.dart';
 
@@ -24,18 +23,17 @@ class TransactionBuilder {
   Transaction _tx;
   Map _prevTxSet = {};
 
-  TransactionBuilder({NetworkType? network, int? maximumFeeRate})
-  : this.network = network ?? bitcoin,
-    this.maximumFeeRate = maximumFeeRate ?? 2500,
-    this._inputs = [],
-    this._tx = new Transaction() {
-    this._tx.version = 2;
+  TransactionBuilder({NetworkType? network, int? maximumFeeRate, int? version})
+      : this.network = network ?? bitcoin,
+        this.maximumFeeRate = maximumFeeRate ?? 2500,
+        this._inputs = [],
+        this._tx = new Transaction(version: version ?? 1) {
+    if (version == null) this._tx.version = 2;
   }
 
   List<Input> get inputs => _inputs;
 
-  factory TransactionBuilder.fromTransaction(Transaction transaction,
-      [NetworkType? network]) {
+  factory TransactionBuilder.fromTransaction(Transaction transaction, [NetworkType? network]) {
     final txb = new TransactionBuilder(network: network);
     // Copy transaction fields
     txb.setVersion(transaction.version);
@@ -47,13 +45,8 @@ class TransactionBuilder {
     });
 
     transaction.ins.forEach((txIn) {
-      txb._addInputUnsafe(
-          txIn.hash!,
-          txIn.index!,
-          new Input(
-              sequence: txIn.sequence,
-              script: txIn.script,
-              witness: txIn.witness));
+      txb._addInputUnsafe(txIn.hash!, txIn.index!,
+          new Input(sequence: txIn.sequence, script: txIn.script, witness: txIn.witness));
     });
 
     // fix some things not possible through the public API
@@ -66,14 +59,12 @@ class TransactionBuilder {
   }
 
   setVersion(int version) {
-    if (version < 0 || version > 0xFFFFFFFF)
-      throw ArgumentError('Expected Uint32');
+    if (version < 0 || version > 0xFFFFFFFF) throw ArgumentError('Expected Uint32');
     _tx.version = version;
   }
 
   setLockTime(int locktime) {
-    if (locktime < 0 || locktime > 0xFFFFFFFF)
-      throw ArgumentError('Expected Uint32');
+    if (locktime < 0 || locktime > 0xFFFFFFFF) throw ArgumentError('Expected Uint32');
     // if any signatures exist, throw
     if (this._inputs.map((input) {
       if (input.signatures == null) return false;
@@ -107,7 +98,8 @@ class TransactionBuilder {
       if (data.length <= MAX_OP_RETURN_SIZE) {
         scriptPubKey = bscript.compile([OPS['OP_RETURN'], utf8.encode(data)]);
       } else {
-        throw new ArgumentError('Too much data embedded, max OP_RETURN size is '+MAX_OP_RETURN_SIZE.toString());
+        throw new ArgumentError(
+            'Too much data embedded, max OP_RETURN size is ' + MAX_OP_RETURN_SIZE.toString());
       }
     } else if (data is Uint8List) {
       scriptPubKey = data;
@@ -121,12 +113,11 @@ class TransactionBuilder {
   }
 
   int addInput(dynamic txHash, int vout,
-      [int? sequence, Uint8List? prevOutScript]) {
+      [int? sequence, Uint8List? prevOutScript, ecpair.ECPair? keyPair, int? value]) {
     if (!_canModifyInputs()) {
       throw new ArgumentError('No, this would invalidate signatures');
     }
     Uint8List hash;
-    var value;
     if (txHash is String) {
       hash = Uint8List.fromList(HEX.decode(txHash).reversed.toList());
     } else if (txHash is Uint8List) {
@@ -143,24 +134,25 @@ class TransactionBuilder {
         hash,
         vout,
         new Input(
-            sequence: sequence, prevOutScript: prevOutScript, value: value));
+            sequence: sequence, prevOutScript: prevOutScript, keyPair: keyPair, value: value));
   }
 
   sign(
       {required int vin,
-      required ECPair keyPair,
+      ecpair.ECPair? keyPair,
       Uint8List? redeemScript,
       int? witnessValue,
       Uint8List? witnessScript,
-      int? hashType}) {
-    if (keyPair.network != null &&
-        keyPair.network.toString().compareTo(network.toString()) != 0)
+      int? hashType,
+      List<int>? amounts,
+      List<Uint8List>? scriptPubKeys,
+      List<dynamic>? inputs}) {
+    keyPair = keyPair ?? _inputs[vin].keyPair!;
+    if (keyPair.network != null && keyPair.network.toString().compareTo(network.toString()) != 0)
       throw new ArgumentError('Inconsistent network');
-    if (vin >= _inputs.length)
-      throw new ArgumentError('No input at index: $vin');
+    if (vin >= _inputs.length) throw new ArgumentError('No input at index: $vin');
     hashType = hashType ?? SIGHASH_ALL;
-    if (this._needsOutputs(hashType))
-      throw new ArgumentError('Transaction needs outputs');
+    if (this._needsOutputs(hashType)) throw new ArgumentError('Transaction needs outputs');
     final input = _inputs[vin];
     final ourPubKey = keyPair.publicKey;
     if (!_canSign(input)) {
@@ -183,21 +175,27 @@ class TransactionBuilder {
           input.hasWitness = true;
           input.signatures = [null];
           input.pubkeys = [ourPubKey];
-          input.signScript = new P2PKH(
-                  data: new PaymentData(pubkey: ourPubKey),
-                  network: this.network)
-              .data
-              .output;
+          input.signScript = new P2pkhAddress(pubkey: ourPubKey.hex, networkType: this.network)
+              .scriptPubkey
+              .toBytes();
+        } else if (type == SCRIPT_TYPES['P2TR']) {
+          input.prevOutType = SCRIPT_TYPES['P2TR'];
+          input.hasWitness = true;
+          input.signatures = [null];
+          input.pubkeys = [ourPubKey];
+          input.signScript = new P2pkhAddress(pubkey: ourPubKey.hex, networkType: this.network)
+              .scriptPubkey
+              .toBytes();
         } else {
           // DRY CODE
-          Uint8List prevOutScript = pubkeyToOutputScript(ourPubKey);
+          Uint8List prevOutScript = _pubkeyToOutputScript(ourPubKey);
           input.prevOutType = SCRIPT_TYPES['P2PKH'];
           input.signatures = [null];
           input.pubkeys = [ourPubKey];
           input.signScript = prevOutScript;
         }
       } else {
-        Uint8List prevOutScript = pubkeyToOutputScript(ourPubKey);
+        Uint8List prevOutScript = _pubkeyToOutputScript(ourPubKey);
         input.prevOutType = SCRIPT_TYPES['P2PKH'];
         input.signatures = [null];
         input.pubkeys = [ourPubKey];
@@ -206,24 +204,25 @@ class TransactionBuilder {
     }
     var signatureHash;
     if (input.hasWitness) {
-      signatureHash = this
-          ._tx
-          .hashForWitnessV0(vin, input.signScript!, input.value!, hashType);
+      signatureHash = this._tx.hashForWitnessV0(vin, input.signScript!, input.value!, hashType);
     } else {
-      signatureHash =
-          this._tx.hashForSignature(vin, input.signScript!, hashType);
+      signatureHash = this._tx.hashForSignature(vin, input.signScript!, hashType);
     }
 
     // enforce in order signing of public keys
     var signed = false;
     for (var i = 0; i < input.pubkeys!.length; i++) {
-      if (HEX.encode(ourPubKey).compareTo(HEX.encode(input.pubkeys![i]!)) != 0)
-        continue;
-      if (input.signatures![i] != null)
-        throw new ArgumentError('Signature already exists');
-      final signature = keyPair.sign(signatureHash);
-      input.signatures![i] = bscript.encodeSignature(signature, hashType);
-      signed = true;
+      if (HEX.encode(ourPubKey).compareTo(HEX.encode(input.pubkeys![i]!)) != 0) continue;
+      if (input.signatures![i] != null) throw new ArgumentError('Signature already exists');
+
+      if (input.prevOutType == SCRIPT_TYPES['P2TR']) {
+        input.signatures![i] = Uint8List.fromList(HEX.decode(signatureHash));
+        signed = true;
+      } else {
+        final signature = keyPair.sign(signatureHash);
+        input.signatures![i] = bscript.encodeSignature(signature, hashType: hashType);
+        signed = true;
+      }
     }
     if (!signed) throw new ArgumentError('Key pair cannot sign for this input');
   }
@@ -238,10 +237,8 @@ class TransactionBuilder {
 
   Transaction _build(bool allowIncomplete) {
     if (!allowIncomplete) {
-      if (_tx.ins.length == 0)
-        throw new ArgumentError('Transaction has no inputs');
-      if (_tx.outs.length == 0)
-        throw new ArgumentError('Transaction has no outputs');
+      if (_tx.ins.length == 0) throw new ArgumentError('Transaction has no inputs');
+      if (_tx.outs.length == 0) throw new ArgumentError('Transaction has no outputs');
     }
 
     final tx = Transaction.clone(_tx);
@@ -252,21 +249,21 @@ class TransactionBuilder {
           _inputs[i].pubkeys!.length != 0 &&
           _inputs[i].signatures!.length != 0) {
         if (_inputs[i].prevOutType == SCRIPT_TYPES['P2PKH']) {
-          P2PKH payment = new P2PKH(
-              data: new PaymentData(
-                  pubkey: _inputs[i].pubkeys![0],
-                  signature: _inputs[i].signatures![0]),
-              network: network);
-          tx.setInputScript(i, payment.data.input);
-          tx.setWitness(i, payment.data.witness);
+          final payment = new P2pkhAddress(
+              pubkey: _inputs[i].pubkeys![0]?.hex,
+              signature: _inputs[i].signatures![0]?.hex,
+              networkType: network);
+          tx.setInputScript(i, payment.sigScript.toBytes());
+          tx.setWitness(i, null);
         } else if (_inputs[i].prevOutType == SCRIPT_TYPES['P2WPKH']) {
           P2WPKH payment = new P2WPKH(
               data: new PaymentData(
-                  pubkey: _inputs[i].pubkeys![0],
-                  signature: _inputs[i].signatures![0]),
+                  pubkey: _inputs[i].pubkeys![0], signature: _inputs[i].signatures![0]),
               network: network);
           tx.setInputScript(i, payment.data.input!);
           tx.setWitness(i, payment.data.witness!);
+        } else if (_inputs[i].prevOutType == SCRIPT_TYPES['P2TR']) {
+          tx.txHex = HEX.encode(_inputs[0].signatures![0]!);
         }
       } else if (!allowIncomplete) {
         throw new ArgumentError('Transaction is not complete');
@@ -330,8 +327,7 @@ class TransactionBuilder {
     // .build() will fail, but .buildIncomplete() is OK
     return (this._tx.outs.length == 0) &&
         _inputs.map((input) {
-          if (input.signatures == null || input.signatures!.length == 0)
-            return false;
+          if (input.signatures == null || input.signatures!.length == 0) return false;
           return input.signatures!.map((signature) {
             if (signature == null) return false; // no signature, no issue
             final hashType = _signatureHashType(signature);
@@ -357,13 +353,12 @@ class TransactionBuilder {
       throw new ArgumentError('coinbase inputs not supported');
     }
     final prevTxOut = '$txHash:$vout';
-    if (_prevTxSet[prevTxOut] != null)
-      throw new ArgumentError('Duplicate TxOut: ' + prevTxOut);
+    if (_prevTxSet[prevTxOut] != null) throw new ArgumentError('Duplicate TxOut: ' + prevTxOut);
     if (options.script != null) {
-      input =
-          Input.expandInput(options.script!, options.witness ?? EMPTY_WITNESS);
+      input = Input.expandInput(options.script!, options.witness ?? EMPTY_WITNESS, null, null,
+          options.keyPair, options.value);
     } else {
-      input = new Input();
+      input = new Input(keyPair: options.keyPair, value: options.value);
     }
     if (options.value != null) input.value = options.value;
     if (input.prevOutScript == null && options.prevOutScript != null) {
@@ -377,6 +372,8 @@ class TransactionBuilder {
       input.prevOutScript = options.prevOutScript;
       input.prevOutType = classifyOutput(options.prevOutScript!);
     }
+    input.hash = hash;
+    input.index = vout;
     int vin = _tx.addInput(hash, vout, options.sequence, options.script);
     _inputs.add(input);
     _prevTxSet[prevTxOut] = true;
@@ -392,9 +389,8 @@ class TransactionBuilder {
   Map get prevTxSet => _prevTxSet;
 }
 
-Uint8List pubkeyToOutputScript(Uint8List pubkey, [NetworkType? nw]) {
+Uint8List _pubkeyToOutputScript(Uint8List pubkey, [NetworkType? nw]) {
   NetworkType network = nw ?? bitcoin;
-  P2PKH p2pkh =
-      new P2PKH(data: new PaymentData(pubkey: pubkey), network: network);
-  return p2pkh.data.output!;
+  final p2pkh = new P2pkhAddress(pubkey: pubkey.hex, networkType: network);
+  return p2pkh.scriptPubkey.toBytes();
 }
diff --git a/lib/src/utils/bigint.dart b/lib/src/utils/bigint.dart
new file mode 100644
index 0000000..2e96fd6
--- /dev/null
+++ b/lib/src/utils/bigint.dart
@@ -0,0 +1,30 @@
+import 'dart:typed_data';
+
+extension BigIntExt on BigInt {
+  Uint8List get decode {
+    var number = this;
+    int needsPaddingByte;
+    int rawSize;
+
+    if (number > BigInt.zero) {
+      rawSize = (number.bitLength + 7) >> 3;
+      needsPaddingByte =
+          ((number >> (rawSize - 1) * 8) & BigInt.from(0x80)) == BigInt.from(0x80) ? 1 : 0;
+
+      if (rawSize < 32) {
+        needsPaddingByte = 1;
+      }
+    } else {
+      needsPaddingByte = 0;
+      rawSize = (number.bitLength + 8) >> 3;
+    }
+
+    final size = rawSize < 32 ? rawSize + needsPaddingByte : rawSize;
+    var result = Uint8List(size);
+    for (int i = 0; i < size; i++) {
+      result[size - i - 1] = (number & BigInt.from(0xff)).toInt();
+      number = number >> 8;
+    }
+    return result;
+  }
+}
diff --git a/lib/src/utils/check_types.dart b/lib/src/utils/check_types.dart
index 43be507..66fca14 100644
--- a/lib/src/utils/check_types.dart
+++ b/lib/src/utils/check_types.dart
@@ -3,7 +3,7 @@ import 'dart:math';
 
 const SATOSHI_MAX = 21 * 1e14;
 
-bool isShatoshi(int value) {
+bool isSatoshi(int value) {
   return isUint(value, 53) && value <= SATOSHI_MAX;
 }
 
diff --git a/lib/src/utils/constants/derivation_paths.dart b/lib/src/utils/constants/derivation_paths.dart
new file mode 100644
index 0000000..bc34334
--- /dev/null
+++ b/lib/src/utils/constants/derivation_paths.dart
@@ -0,0 +1,2 @@
+const SCAN_PATH = "m/352'/1'/0'/1'/0";
+const SPEND_PATH = "m/352'/1'/0'/0'/0";
diff --git a/lib/src/utils/int.dart b/lib/src/utils/int.dart
new file mode 100644
index 0000000..f8609e8
--- /dev/null
+++ b/lib/src/utils/int.dart
@@ -0,0 +1,15 @@
+import 'dart:typed_data';
+
+extension IntExt on int {
+  Uint8List get toLittleEndianBytes {
+    var buffer = ByteData(4);
+    buffer.setInt32(0, this, Endian.little);
+    return buffer.buffer.asUint8List();
+  }
+
+  Uint8List get toBigEndianBytes {
+    var buffer = ByteData(4);
+    buffer.setUint32(0, this, Endian.big);
+    return buffer.buffer.asUint8List();
+  }
+}
diff --git a/lib/src/utils/keys.dart b/lib/src/utils/keys.dart
new file mode 100644
index 0000000..229602a
--- /dev/null
+++ b/lib/src/utils/keys.dart
@@ -0,0 +1,33 @@
+import 'package:elliptic/elliptic.dart';
+
+class PrivateKeyInfo {
+  final PrivateKey key;
+  final bool isTaproot;
+
+  PrivateKeyInfo(this.key, this.isTaproot);
+}
+
+PublicKey getSumInputPubKeys(List<String> pubkeys) {
+  final curve = getSecp256k1();
+  List<PublicKey> negatedKeys = [];
+
+  for (final info in pubkeys) {
+    negatedKeys.add(PublicKey.fromHex(curve, info));
+
+    // if (isTaproot && key.toCompressedHex().fromHex[0] == 0x03) {
+    //   negatedKeys.add(PublicKey(getSecp256k1(), key.X, key.Y).negate()!);
+    // } else {
+    //   negatedKeys.add(key);
+    // }
+  }
+
+  final head = negatedKeys.first;
+  final tail = negatedKeys.sublist(1);
+
+  final result = tail.fold<PublicKey>(
+    head,
+    (acc, item) => PublicKey(getSecp256k1(), acc.X, acc.Y).pubkeyAdd(item),
+  );
+
+  return result;
+}
diff --git a/lib/src/utils/magic_hash.dart b/lib/src/utils/magic_hash.dart
index 807a125..b524cf0 100644
--- a/lib/src/utils/magic_hash.dart
+++ b/lib/src/utils/magic_hash.dart
@@ -2,7 +2,7 @@ import 'dart:typed_data';
 import 'dart:convert';
 import '../../src/crypto.dart';
 import 'varuint.dart';
-import '../../src/models/networks.dart';
+import 'package:bitcoin_flutter/src/models/networks.dart';
 
 Uint8List magicHash(String message, NetworkType? network) {
   network = network ?? bitcoin;
diff --git a/lib/src/utils/script.dart b/lib/src/utils/script.dart
index d24f5c6..c7b9b2c 100644
--- a/lib/src/utils/script.dart
+++ b/lib/src/utils/script.dart
@@ -2,11 +2,11 @@ import 'dart:typed_data';
 import 'package:hex/hex.dart';
 import 'package:bip32/src/utils/ecurve.dart' as ecc;
 import 'constants/op.dart';
+import 'package:bitcoin_flutter/src/payments/constants/constants.dart';
 import 'push_data.dart' as pushData;
 import 'check_types.dart';
 
-Map<int, String> REVERSE_OPS =
-    OPS.map((String string, int number) => new MapEntry(number, string));
+Map<int, String> REVERSE_OPS = OPS.map((String string, int number) => new MapEntry(number, string));
 final OP_INT_BASE = OPS['OP_RESERVED'];
 final ZERO = Uint8List.fromList([0]);
 
@@ -31,8 +31,7 @@ Uint8List compile(List<dynamic> chunks) {
         offset += 1;
         return null;
       }
-      pushData.EncodedPushData epd =
-          pushData.encode(buffer, chunk.length, offset);
+      pushData.EncodedPushData epd = pushData.encode(buffer, chunk.length, offset);
       offset += epd.size;
       buffer = epd.buffer;
       buffer.setRange(offset, offset + chunk.length, chunk);
@@ -44,8 +43,7 @@ Uint8List compile(List<dynamic> chunks) {
     }
   });
 
-  if (offset != buffer.length)
-    throw new ArgumentError("Could not decode chunks");
+  if (offset != buffer.length) throw new ArgumentError("Could not decode chunks");
   return buffer;
 }
 
@@ -160,8 +158,7 @@ bool bip66check(buffer) {
   if (lenR > 1 && (buffer[4] == 0x00) && buffer[5] & 0x80 == 0) return false;
 
   if (buffer[lenR + 6] & 0x80 != 0) return false;
-  if (lenS > 1 && (buffer[lenR + 6] == 0x00) && buffer[lenR + 7] & 0x80 == 0)
-    return false;
+  if (lenS > 1 && (buffer[lenR + 6] == 0x00) && buffer[lenR + 7] & 0x80 == 0) return false;
   return true;
 }
 
@@ -193,12 +190,12 @@ Uint8List bip66encode(Uint8List r, Uint8List s) {
   return signature;
 }
 
-Uint8List encodeSignature(Uint8List signature, int hashType) {
+Uint8List encodeSignature(Uint8List signature, {int? hashType}) {
+  hashType = hashType ?? SIGHASH_ALL;
   if (!isUint(hashType, 8)) throw ArgumentError("Invalid hasType $hashType");
   if (signature.length != 64) throw ArgumentError("Invalid signature");
   final hashTypeMod = hashType & ~0x80;
-  if (hashTypeMod <= 0 || hashTypeMod >= 4)
-    throw new ArgumentError('Invalid hashType $hashType');
+  if (hashTypeMod <= 0 || hashTypeMod >= 4) throw new ArgumentError('Invalid hashType $hashType');
 
   final hashTypeBuffer = new Uint8List(1);
   hashTypeBuffer.buffer.asByteData().setUint8(0, hashType);
diff --git a/lib/src/utils/string.dart b/lib/src/utils/string.dart
new file mode 100644
index 0000000..b20db0d
--- /dev/null
+++ b/lib/src/utils/string.dart
@@ -0,0 +1,18 @@
+import 'dart:typed_data';
+
+import 'package:hex/hex.dart';
+
+extension StringExt on String {
+  Uint8List get fromHex {
+    return Uint8List.fromList(HEX.decode(this));
+  }
+
+  String get strip0x {
+    if (this.startsWith('0x')) return this.substring(2);
+    return this;
+  }
+
+  Uint8List get hexToBytes {
+    return this.strip0x.fromHex;
+  }
+}
diff --git a/lib/src/utils/uint8list.dart b/lib/src/utils/uint8list.dart
new file mode 100644
index 0000000..d21df50
--- /dev/null
+++ b/lib/src/utils/uint8list.dart
@@ -0,0 +1,68 @@
+import 'dart:typed_data';
+import 'package:hex/hex.dart';
+import 'package:bitcoin_flutter/src/ec/ec_encryption.dart' as ec;
+import 'package:bitcoin_flutter/src/crypto.dart' as crypto;
+
+extension Uint8ListExt on Uint8List {
+  int compare(Uint8List list2) {
+    final list1 = this;
+
+    for (var i = 0; i < list1.length && i < list2.length; i += 1) {
+      if (list1[i] < list2[i]) {
+        return -1;
+      } else if (list1[i] > list2[i]) {
+        return 1;
+      }
+    }
+
+    if (list1.length < list2.length) {
+      return -1;
+    } else if (list1.length > list2.length) {
+      return 1;
+    }
+
+    return 0;
+  }
+
+  Uint8List concat(List<Uint8List> concatLists) {
+    return concatenateUint8Lists([this, ...concatLists]);
+  }
+
+  String get hex {
+    return HEX.encode(this);
+  }
+
+  BigInt get bigint {
+    // Create an empty BigInt
+    BigInt result = BigInt.zero;
+
+    // Iterate over the bytes in the Uint8List
+    for (int i = 0; i < this.length; i++) {
+      // Left-shift the existing value by 8 bits and add the current byte
+      result = (result << 8) + BigInt.from(this[i]);
+    }
+
+    return result;
+  }
+
+  bool get isPoint {
+    return ec.isPoint(this);
+  }
+
+  Uint8List get ripemd160Hash {
+    return crypto.hash160(this);
+  }
+}
+
+Uint8List concatenateUint8Lists(List<Uint8List> lists) {
+  var totalLength = lists.fold(0, (sum, list) => sum + list.length);
+  var result = Uint8List(totalLength);
+  var offset = 0;
+
+  for (var list in lists) {
+    result.setRange(offset, offset + list.length, list);
+    offset += list.length;
+  }
+
+  return result;
+}
diff --git a/pubspec.yaml b/pubspec.yaml
index 89e8c13..66cf560 100644
--- a/pubspec.yaml
+++ b/pubspec.yaml
@@ -5,7 +5,7 @@ homepage: https://github.com/anicdh
 publish_to: none
 
 environment:
-  sdk: ">=2.12.0 <3.0.0"
+  sdk: ">=3.0.0 <4.0.0"
 
 dependencies:
   bip39: ^1.0.6
@@ -15,8 +15,12 @@ dependencies:
   bs58check: ^1.0.2
   bech32:
     git:
-      url: https://github.com/cake-tech/bech32.git
-      ref: cake-0.2.2
+      url: https://github.com/saltrafael/bech32.git
+      ref: bech32m
+  elliptic:
+    git:
+      url: https://github.com/cake-tech/dart-elliptic
+      ref: silent-payments
 
 dev_dependencies:
   test: ^1.24.9
diff --git a/test/address_test.dart b/test/address_test.dart
index 95bcb8c..73aa507 100644
--- a/test/address_test.dart
+++ b/test/address_test.dart
@@ -1,52 +1,138 @@
+import 'package:bip32/bip32.dart';
+import 'package:bitcoin_flutter/src/templates/silentpaymentaddress.dart';
+import 'package:bitcoin_flutter/src/utils/constants/derivation_paths.dart';
+import 'package:elliptic/elliptic.dart';
 import 'package:test/test.dart';
 import '../lib/src/address.dart' show Address;
-import '../lib/src/models/networks.dart' as NETWORKS;
+import 'package:bitcoin_flutter/src/models/networks.dart' as NETWORKS;
+import '../lib/src/utils/string.dart';
+import 'package:bip39/bip39.dart' as bip39;
 
 main() {
   group('Address', () {
-    group('validateAddress', () {
-      test('base58 addresses and valid network', () {
-        expect(
-            Address.validateAddress(
-                'mhv6wtF2xzEqMNd3TbXx9TjLLo6mp2MUuT', NETWORKS.testnet),
-            true);
-        expect(Address.validateAddress('1K6kARGhcX9nJpJeirgcYdGAgUsXD59nHZ'),
-            true);
-      });
-      test('base58 addresses and invalid network', () {
-        expect(
-            Address.validateAddress(
-                'mhv6wtF2xzEqMNd3TbXx9TjLLo6mp2MUuT', NETWORKS.bitcoin),
-            false);
+    group('silent payment addresses', () {
+      final scanKey = '036a1035a192f8f5fd375556f36ea4abc387361d32c709831ec624a5b73d0b7b9d';
+      final spendKey = '028eaf19db65cece905cf2b3eab811148d6fe874089a4a68e5d8b0a1a0904f6bd0';
+      final silentAddress =
+          'sprt1qqd4pqddpjtu0tlfh24t0xm4y40pcwdsaxtrsnqc7ccj2tdeapdae6q5w4uvakewwe6g9eu4na2upz9yddl58gzy6ff5wtk9s5xsfqnmt6q30zssg';
+
+      final curve = getSecp256k1();
+
+      test('can encode scan and spend key to silent payment address', () {
         expect(
-            Address.validateAddress(
-                '1K6kARGhcX9nJpJeirgcYdGAgUsXD59nHZ', NETWORKS.testnet),
-            false);
+            SilentPaymentAddress(
+                    scanPubkey: PublicKey.fromHex(curve, scanKey),
+                    spendPubkey: PublicKey.fromHex(curve, spendKey),
+                    hrp: 'sprt',
+                    version: 0)
+                .toString(),
+            silentAddress);
       });
-      test('bech32 addresses and valid network', () {
+      test('can decode scan and spend key from silent payment address', () {
         expect(
-            Address.validateAddress(
-                'tb1qgmp0h7lvexdxx9y05pmdukx09xcteu9sx2h4ya', NETWORKS.testnet),
-            true);
-        expect(
-            Address.validateAddress(
-                'bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t4'),
-            true);
-        // expect(Address.validateAddress('tb1qqqqqp399et2xygdj5xreqhjjvcmzhxw4aywxecjdzew6hylgvsesrxh6hy'), true); TODO
+            SilentPaymentAddress.fromString(silentAddress).toString(),
+            SilentPaymentAddress(
+                    scanPubkey: PublicKey.fromHex(curve, scanKey),
+                    spendPubkey: PublicKey.fromHex(curve, spendKey),
+                    hrp: 'sprt',
+                    version: 0)
+                .toString());
       });
-      test('bech32 addresses and invalid network', () {
+
+      test('can derive scan and spend key from master key', () async {
+        const mnemonic =
+            'praise you muffin lion enable neck grocery crumble super myself license ghost';
+        final address = await SilentPaymentReceiver.fromMnemonic(mnemonic);
+
+        final seed = bip39.mnemonicToSeed(mnemonic);
+        final root = BIP32.fromSeed(seed);
+
         expect(
-            Address.validateAddress(
-                'tb1qgmp0h7lvexdxx9y05pmdukx09xcteu9sx2h4ya'),
-            false);
+            address.scanPrivkey.toCompressedHex().fromHex, root.derivePath(SCAN_PATH).privateKey!);
+        expect(address.scanPubkey.toCompressedHex().fromHex, root.derivePath(SCAN_PATH).publicKey);
+
+        expect(address.spendPrivkey.toCompressedHex().fromHex,
+            root.derivePath(SPEND_PATH).privateKey!);
         expect(
-            Address.validateAddress(
-                'bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t4', NETWORKS.testnet),
-            false);
+            address.spendPubkey.toCompressedHex().fromHex, root.derivePath(SPEND_PATH).publicKey);
       });
-      test('invalid addresses', () {
-        expect(Address.validateAddress('3333333casca'), false);
+
+      test('can create a labeled silent payment address', () {
+        final given = [
+          (
+            '0220bcfac5b99e04ad1a06ddfb016ee13582609d60b6291e98d01a9bc9a16c96d4',
+            '025cc9856d6f8375350e123978daac200c260cb5b5ae83106cab90484dcd8fcf36',
+            '0000000000000000000000000000000000000000000000000000000000000001',
+            'sp1qqgste7k9hx0qftg6qmwlkqtwuy6cycyavzmzj85c6qdfhjdpdjtdgqah4hxfsjdwyaeel4g8x2npkj7qlvf2692l5760z5ut0ggnlrhdzsy3cvsj',
+          ),
+          (
+            '0220bcfac5b99e04ad1a06ddfb016ee13582609d60b6291e98d01a9bc9a16c96d4',
+            '025cc9856d6f8375350e123978daac200c260cb5b5ae83106cab90484dcd8fcf36',
+            '0000000000000000000000000000000000000000000000000000000000000539',
+            'sp1qqgste7k9hx0qftg6qmwlkqtwuy6cycyavzmzj85c6qdfhjdpdjtdgq562yg7htxyg8eq60rl37uul37jy62apnf5ru62uef0eajpdfrnp5cmqndj',
+          ),
+          (
+            '03b4cc0b090b6f49a684558852db60ee5eb1c5f74352839c3d18a8fc04ef7354e0',
+            '03bc95144daf15336db3456825c70ced0a4462f89aca42c4921ee7ccb2b3a44796',
+            '91cb04398a508c9d995ff4a18e5eae24d5e9488309f189120a3fdbb977978c46',
+            'sp1qqw6vczcfpdh5nf5y2ky99kmqae0tr30hgdfg88parz50cp80wd2wqqll5497pp2gcr4cmq0v5nv07x8u5jswmf8ap2q0kxmx8628mkqanyu63ck8',
+          ),
+        ];
+
+        given.forEach((data) {
+          final (scanKey, spendKey, label, address) = data;
+          final result = SilentPaymentAddress.createLabeledSilentPaymentAddress(
+              PublicKey.fromHex(curve, scanKey), PublicKey.fromHex(curve, spendKey), label.fromHex);
+
+          expect(result.toString(), address);
+        });
       });
     });
+    test('base58 addresses and valid network', () {
+      expect(Address.validateAddress('mhv6wtF2xzEqMNd3TbXx9TjLLo6mp2MUuT', NETWORKS.testnet), true);
+      expect(Address.validateAddress('1K6kARGhcX9nJpJeirgcYdGAgUsXD59nHZ'), true);
+    });
+    test('base58 addresses and invalid network', () {
+      expect(
+          Address.validateAddress('mhv6wtF2xzEqMNd3TbXx9TjLLo6mp2MUuT', NETWORKS.bitcoin), false);
+      expect(
+          Address.validateAddress('1K6kARGhcX9nJpJeirgcYdGAgUsXD59nHZ', NETWORKS.testnet), false);
+    });
+    test('bech32 addresses and valid network', () {
+      expect(
+          Address.validateAddress('tb1qgmp0h7lvexdxx9y05pmdukx09xcteu9sx2h4ya', NETWORKS.testnet),
+          true);
+      expect(Address.validateAddress('bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t4'), true);
+      // expect(Address.validateAddress('tb1qqqqqp399et2xygdj5xreqhjjvcmzhxw4aywxecjdzew6hylgvsesrxh6hy'), true); TODO
+    });
+    test('bech32 addresses and invalid network', () {
+      expect(Address.validateAddress('tb1qgmp0h7lvexdxx9y05pmdukx09xcteu9sx2h4ya'), false);
+      expect(
+          Address.validateAddress('bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t4', NETWORKS.testnet),
+          false);
+    });
+    test('bech32m addresses and valid network', () {
+      expect(
+          Address.validateAddress(
+              'tb1pk426x6qvmncj5vzhtp5f2pzhdu4qxsshszswga8ea6sycj9nulmsu7syz0', NETWORKS.testnet),
+          true);
+      expect(
+          Address.validateAddress(
+              'bc1pw508d6qejxtdg4y5r3zarvary0c5xw7kw508d6qejxtdg4y5r3zarvary0c5xw7kt5nd6y'),
+          true);
+    });
+    test('bech32m addresses and invalid network', () {
+      expect(
+          Address.validateAddress('tb1pk426x6qvmncj5vzhtp5f2pzhdu4qxsshszswga8ea6sycj9nulmsu7syz0'),
+          false);
+      expect(
+          Address.validateAddress(
+              'bc1pw508d6qejxtdg4y5r3zarvary0c5xw7kw508d6qejxtdg4y5r3zarvary0c5xw7kt5nd6y',
+              NETWORKS.testnet),
+          false);
+    });
+    test('invalid addresses', () {
+      expect(Address.validateAddress('3333333casca'), false);
+    });
   });
 }
diff --git a/test/ecpair_test.dart b/test/ecpair_test.dart
index f9d8e96..3cdca82 100644
--- a/test/ecpair_test.dart
+++ b/test/ecpair_test.dart
@@ -4,7 +4,7 @@ import 'dart:typed_data';
 import 'dart:io';
 import 'dart:convert';
 import '../lib/src/ecpair.dart' show ECPair;
-import '../lib/src/models/networks.dart' as NETWORKS;
+import 'package:bitcoin_flutter/src/models/networks.dart' as NETWORKS;
 
 final ONE = HEX
     .decode('0000000000000000000000000000000000000000000000000000000000000001');
diff --git a/test/fixtures/silent_payments.json b/test/fixtures/silent_payments.json
new file mode 100644
index 0000000..ef56fbb
--- /dev/null
+++ b/test/fixtures/silent_payments.json
@@ -0,0 +1,1743 @@
+[
+    {
+        "comment": "Simple send: two inputs",
+        "sending": [
+            {
+                "given": {
+                    "outpoints": [
+                        [
+                            "f4184fc596403b9d638783cf57adfe4c75c605f6356fbc91338530e9831e9e16",
+                            0
+                        ],
+                        [
+                            "a1075db55d416d3ca199f55b6084e2115b9345e16c5cf302fc80e9d5fbf5d48d",
+                            0
+                        ]
+                    ],
+                    "input_priv_keys": [
+                        [
+                            "eadc78165ff1f8ea94ad7cfdc54990738a4c53f6e0507b42154201b8e5dff3b1",
+                            false
+                        ],
+                        [
+                            "93f5ed907ad5b2bdbbdcb5d9116ebc0a4e1f92f910d5260237fa45a9408aad16",
+                            false
+                        ]
+                    ],
+                    "recipients": [
+                        [
+                            "sp1qqgste7k9hx0qftg6qmwlkqtwuy6cycyavzmzj85c6qdfhjdpdjtdgqjuexzk6murw56suy3e0rd2cgqvycxttddwsvgxe2usfpxumr70xc9pkqwv",
+                            1.0
+                        ]
+                    ]
+                },
+                "expected": {
+                    "outputs": [
+                        [
+                            "39a1e5ff6206cd316151b9b34cee4f80bb48ce61adee0a12ce7ff05ea436a1d9",
+                            1.0
+                        ]
+                    ]
+                }
+            }
+        ],
+        "receiving": [
+            {
+                "supports_labels": false,
+                "given": {
+                    "outpoints": [
+                        [
+                            "f4184fc596403b9d638783cf57adfe4c75c605f6356fbc91338530e9831e9e16",
+                            0
+                        ],
+                        [
+                            "a1075db55d416d3ca199f55b6084e2115b9345e16c5cf302fc80e9d5fbf5d48d",
+                            0
+                        ]
+                    ],
+                    "input_pub_keys": [
+                        "025a1e61f898173040e20616d43e9f496fba90338a39faa1ed98fcbaeee4dd9be5",
+                        "03bd85685d03d111699b15d046319febe77f8de5286e9e512703cdee1bf3be3792"
+                    ],
+                    "bip32_seed": "f00dbabe",
+                    "scan_priv_key": "0f694e068028a717f8af6b9411f9a133dd3565258714cc226594b34db90c1f2c",
+                    "spend_priv_key": "9d6ad855ce3417ef84e836892e5a56392bfba05fa5d97ccea30e266f540e08b3",
+                    "labels": {},
+                    "outputs": [
+                        "39a1e5ff6206cd316151b9b34cee4f80bb48ce61adee0a12ce7ff05ea436a1d9"
+                    ]
+                },
+                "expected": {
+                    "addresses": [
+                        "sp1qqgste7k9hx0qftg6qmwlkqtwuy6cycyavzmzj85c6qdfhjdpdjtdgqjuexzk6murw56suy3e0rd2cgqvycxttddwsvgxe2usfpxumr70xc9pkqwv"
+                    ],
+                    "outputs": [
+                        {
+                            "pub_key": "39a1e5ff6206cd316151b9b34cee4f80bb48ce61adee0a12ce7ff05ea436a1d9",
+                            "priv_key_tweak": "8e4bbee712779f746337cadf39e8b1eab8e8869dd40f2e3a7281113e858ffc0b",
+                            "signature": "e18fe06280456ed533808606f73e0d46dea49f90751078d127379a8e176a6e56bb1e86f4ca3522a58e760a4ea68e6f3a26b24dcbcb9c614d4d5d2bce9bf956bf"
+                        }
+                    ]
+                }
+            }
+        ]
+    },
+    {
+        "comment": "Simple send: two inputs, order reversed",
+        "sending": [
+            {
+                "given": {
+                    "outpoints": [
+                        [
+                            "a1075db55d416d3ca199f55b6084e2115b9345e16c5cf302fc80e9d5fbf5d48d",
+                            0
+                        ],
+                        [
+                            "f4184fc596403b9d638783cf57adfe4c75c605f6356fbc91338530e9831e9e16",
+                            0
+                        ]
+                    ],
+                    "input_priv_keys": [
+                        [
+                            "eadc78165ff1f8ea94ad7cfdc54990738a4c53f6e0507b42154201b8e5dff3b1",
+                            false
+                        ],
+                        [
+                            "93f5ed907ad5b2bdbbdcb5d9116ebc0a4e1f92f910d5260237fa45a9408aad16",
+                            false
+                        ]
+                    ],
+                    "recipients": [
+                        [
+                            "sp1qqgste7k9hx0qftg6qmwlkqtwuy6cycyavzmzj85c6qdfhjdpdjtdgqjuexzk6murw56suy3e0rd2cgqvycxttddwsvgxe2usfpxumr70xc9pkqwv",
+                            1.0
+                        ]
+                    ]
+                },
+                "expected": {
+                    "outputs": [
+                        [
+                            "39a1e5ff6206cd316151b9b34cee4f80bb48ce61adee0a12ce7ff05ea436a1d9",
+                            1.0
+                        ]
+                    ]
+                }
+            }
+        ],
+        "receiving": [
+            {
+                "supports_labels": false,
+                "given": {
+                    "outpoints": [
+                        [
+                            "a1075db55d416d3ca199f55b6084e2115b9345e16c5cf302fc80e9d5fbf5d48d",
+                            0
+                        ],
+                        [
+                            "f4184fc596403b9d638783cf57adfe4c75c605f6356fbc91338530e9831e9e16",
+                            0
+                        ]
+                    ],
+                    "input_pub_keys": [
+                        "025a1e61f898173040e20616d43e9f496fba90338a39faa1ed98fcbaeee4dd9be5",
+                        "03bd85685d03d111699b15d046319febe77f8de5286e9e512703cdee1bf3be3792"
+                    ],
+                    "bip32_seed": "f00dbabe",
+                    "scan_priv_key": "0f694e068028a717f8af6b9411f9a133dd3565258714cc226594b34db90c1f2c",
+                    "spend_priv_key": "9d6ad855ce3417ef84e836892e5a56392bfba05fa5d97ccea30e266f540e08b3",
+                    "labels": {},
+                    "outputs": [
+                        "39a1e5ff6206cd316151b9b34cee4f80bb48ce61adee0a12ce7ff05ea436a1d9"
+                    ]
+                },
+                "expected": {
+                    "addresses": [
+                        "sp1qqgste7k9hx0qftg6qmwlkqtwuy6cycyavzmzj85c6qdfhjdpdjtdgqjuexzk6murw56suy3e0rd2cgqvycxttddwsvgxe2usfpxumr70xc9pkqwv"
+                    ],
+                    "outputs": [
+                        {
+                            "pub_key": "39a1e5ff6206cd316151b9b34cee4f80bb48ce61adee0a12ce7ff05ea436a1d9",
+                            "priv_key_tweak": "8e4bbee712779f746337cadf39e8b1eab8e8869dd40f2e3a7281113e858ffc0b",
+                            "signature": "e18fe06280456ed533808606f73e0d46dea49f90751078d127379a8e176a6e56bb1e86f4ca3522a58e760a4ea68e6f3a26b24dcbcb9c614d4d5d2bce9bf956bf"
+                        }
+                    ]
+                }
+            }
+        ]
+    },
+    {
+        "comment": "Simple send: two inputs from the same transaction",
+        "sending": [
+            {
+                "given": {
+                    "outpoints": [
+                        [
+                            "f4184fc596403b9d638783cf57adfe4c75c605f6356fbc91338530e9831e9e16",
+                            3
+                        ],
+                        [
+                            "f4184fc596403b9d638783cf57adfe4c75c605f6356fbc91338530e9831e9e16",
+                            7
+                        ]
+                    ],
+                    "input_priv_keys": [
+                        [
+                            "eadc78165ff1f8ea94ad7cfdc54990738a4c53f6e0507b42154201b8e5dff3b1",
+                            false
+                        ],
+                        [
+                            "93f5ed907ad5b2bdbbdcb5d9116ebc0a4e1f92f910d5260237fa45a9408aad16",
+                            false
+                        ]
+                    ],
+                    "recipients": [
+                        [
+                            "sp1qqgste7k9hx0qftg6qmwlkqtwuy6cycyavzmzj85c6qdfhjdpdjtdgqjuexzk6murw56suy3e0rd2cgqvycxttddwsvgxe2usfpxumr70xc9pkqwv",
+                            1.0
+                        ]
+                    ]
+                },
+                "expected": {
+                    "outputs": [
+                        [
+                            "162f2298705b3ddca01ce1d214eedff439df3927582938d08e29e464908db00b",
+                            1.0
+                        ]
+                    ]
+                }
+            }
+        ],
+        "receiving": [
+            {
+                "supports_labels": false,
+                "given": {
+                    "outpoints": [
+                        [
+                            "f4184fc596403b9d638783cf57adfe4c75c605f6356fbc91338530e9831e9e16",
+                            3
+                        ],
+                        [
+                            "f4184fc596403b9d638783cf57adfe4c75c605f6356fbc91338530e9831e9e16",
+                            7
+                        ]
+                    ],
+                    "input_pub_keys": [
+                        "025a1e61f898173040e20616d43e9f496fba90338a39faa1ed98fcbaeee4dd9be5",
+                        "03bd85685d03d111699b15d046319febe77f8de5286e9e512703cdee1bf3be3792"
+                    ],
+                    "bip32_seed": "f00dbabe",
+                    "scan_priv_key": "0f694e068028a717f8af6b9411f9a133dd3565258714cc226594b34db90c1f2c",
+                    "spend_priv_key": "9d6ad855ce3417ef84e836892e5a56392bfba05fa5d97ccea30e266f540e08b3",
+                    "labels": {},
+                    "outputs": [
+                        "162f2298705b3ddca01ce1d214eedff439df3927582938d08e29e464908db00b"
+                    ]
+                },
+                "expected": {
+                    "addresses": [
+                        "sp1qqgste7k9hx0qftg6qmwlkqtwuy6cycyavzmzj85c6qdfhjdpdjtdgqjuexzk6murw56suy3e0rd2cgqvycxttddwsvgxe2usfpxumr70xc9pkqwv"
+                    ],
+                    "outputs": [
+                        {
+                            "pub_key": "162f2298705b3ddca01ce1d214eedff439df3927582938d08e29e464908db00b",
+                            "priv_key_tweak": "f06d8d90561bdbc3e511c3bec7355ad3c858aaf38a132c772d6cd82ec04102ac",
+                            "signature": "4c900d573964d31953acdaedbcbb7866fedbdc215417adfd4173073f86179cad5903ae64490629fae610bf879263c3b9f5c7e6ec1b32a159e2d2e60a16d36597"
+                        }
+                    ]
+                }
+            }
+        ]
+    },
+    {
+        "comment": "Simple send: two inputs from the same transaction, order reversed",
+        "sending": [
+            {
+                "given": {
+                    "outpoints": [
+                        [
+                            "a1075db55d416d3ca199f55b6084e2115b9345e16c5cf302fc80e9d5fbf5d48d",
+                            7
+                        ],
+                        [
+                            "a1075db55d416d3ca199f55b6084e2115b9345e16c5cf302fc80e9d5fbf5d48d",
+                            3
+                        ]
+                    ],
+                    "input_priv_keys": [
+                        [
+                            "eadc78165ff1f8ea94ad7cfdc54990738a4c53f6e0507b42154201b8e5dff3b1",
+                            false
+                        ],
+                        [
+                            "93f5ed907ad5b2bdbbdcb5d9116ebc0a4e1f92f910d5260237fa45a9408aad16",
+                            false
+                        ]
+                    ],
+                    "recipients": [
+                        [
+                            "sp1qqgste7k9hx0qftg6qmwlkqtwuy6cycyavzmzj85c6qdfhjdpdjtdgqjuexzk6murw56suy3e0rd2cgqvycxttddwsvgxe2usfpxumr70xc9pkqwv",
+                            1.0
+                        ]
+                    ]
+                },
+                "expected": {
+                    "outputs": [
+                        [
+                            "d9ede52f7e1e64e36ccf895ca0250daad96b174987079c903519b17852b21a3f",
+                            1.0
+                        ]
+                    ]
+                }
+            }
+        ],
+        "receiving": [
+            {
+                "supports_labels": false,
+                "given": {
+                    "outpoints": [
+                        [
+                            "a1075db55d416d3ca199f55b6084e2115b9345e16c5cf302fc80e9d5fbf5d48d",
+                            7
+                        ],
+                        [
+                            "a1075db55d416d3ca199f55b6084e2115b9345e16c5cf302fc80e9d5fbf5d48d",
+                            3
+                        ]
+                    ],
+                    "input_pub_keys": [
+                        "025a1e61f898173040e20616d43e9f496fba90338a39faa1ed98fcbaeee4dd9be5",
+                        "03bd85685d03d111699b15d046319febe77f8de5286e9e512703cdee1bf3be3792"
+                    ],
+                    "bip32_seed": "f00dbabe",
+                    "scan_priv_key": "0f694e068028a717f8af6b9411f9a133dd3565258714cc226594b34db90c1f2c",
+                    "spend_priv_key": "9d6ad855ce3417ef84e836892e5a56392bfba05fa5d97ccea30e266f540e08b3",
+                    "labels": {},
+                    "outputs": [
+                        "d9ede52f7e1e64e36ccf895ca0250daad96b174987079c903519b17852b21a3f"
+                    ]
+                },
+                "expected": {
+                    "addresses": [
+                        "sp1qqgste7k9hx0qftg6qmwlkqtwuy6cycyavzmzj85c6qdfhjdpdjtdgqjuexzk6murw56suy3e0rd2cgqvycxttddwsvgxe2usfpxumr70xc9pkqwv"
+                    ],
+                    "outputs": [
+                        {
+                            "pub_key": "d9ede52f7e1e64e36ccf895ca0250daad96b174987079c903519b17852b21a3f",
+                            "priv_key_tweak": "44b827516c2128287b1d571add7cfeb42f122e86bc40b4eb2b21ac144607fdb2",
+                            "signature": "1bdb32461dd502ee9c19c7dff5f3801a26c2bc0ffe6f34671053ef7083ea0d5adca6036564252a76e427555deb17edd6f801d45cd7b830d7e3003eb3c8c85263"
+                        }
+                    ]
+                }
+            }
+        ]
+    },
+    {
+        "comment": "Single recipient: multiple UTXOs from the same public key",
+        "sending": [
+            {
+                "given": {
+                    "outpoints": [
+                        [
+                            "f4184fc596403b9d638783cf57adfe4c75c605f6356fbc91338530e9831e9e16",
+                            0
+                        ],
+                        [
+                            "a1075db55d416d3ca199f55b6084e2115b9345e16c5cf302fc80e9d5fbf5d48d",
+                            0
+                        ]
+                    ],
+                    "input_priv_keys": [
+                        [
+                            "eadc78165ff1f8ea94ad7cfdc54990738a4c53f6e0507b42154201b8e5dff3b1",
+                            false
+                        ],
+                        [
+                            "eadc78165ff1f8ea94ad7cfdc54990738a4c53f6e0507b42154201b8e5dff3b1",
+                            false
+                        ]
+                    ],
+                    "recipients": [
+                        [
+                            "sp1qqgste7k9hx0qftg6qmwlkqtwuy6cycyavzmzj85c6qdfhjdpdjtdgqjuexzk6murw56suy3e0rd2cgqvycxttddwsvgxe2usfpxumr70xc9pkqwv",
+                            1.0
+                        ]
+                    ]
+                },
+                "expected": {
+                    "outputs": [
+                        [
+                            "0aafdcdb5893ae813299b16eea75f34ec16653ac39171da04d7c4e6d2e09ab8e",
+                            1.0
+                        ]
+                    ]
+                }
+            }
+        ],
+        "receiving": [
+            {
+                "supports_labels": false,
+                "given": {
+                    "outpoints": [
+                        [
+                            "f4184fc596403b9d638783cf57adfe4c75c605f6356fbc91338530e9831e9e16",
+                            0
+                        ],
+                        [
+                            "a1075db55d416d3ca199f55b6084e2115b9345e16c5cf302fc80e9d5fbf5d48d",
+                            0
+                        ]
+                    ],
+                    "input_pub_keys": [
+                        "025a1e61f898173040e20616d43e9f496fba90338a39faa1ed98fcbaeee4dd9be5",
+                        "025a1e61f898173040e20616d43e9f496fba90338a39faa1ed98fcbaeee4dd9be5"
+                    ],
+                    "bip32_seed": "f00dbabe",
+                    "scan_priv_key": "0f694e068028a717f8af6b9411f9a133dd3565258714cc226594b34db90c1f2c",
+                    "spend_priv_key": "9d6ad855ce3417ef84e836892e5a56392bfba05fa5d97ccea30e266f540e08b3",
+                    "labels": {},
+                    "outputs": [
+                        "0aafdcdb5893ae813299b16eea75f34ec16653ac39171da04d7c4e6d2e09ab8e"
+                    ]
+                },
+                "expected": {
+                    "addresses": [
+                        "sp1qqgste7k9hx0qftg6qmwlkqtwuy6cycyavzmzj85c6qdfhjdpdjtdgqjuexzk6murw56suy3e0rd2cgqvycxttddwsvgxe2usfpxumr70xc9pkqwv"
+                    ],
+                    "outputs": [
+                        {
+                            "pub_key": "0aafdcdb5893ae813299b16eea75f34ec16653ac39171da04d7c4e6d2e09ab8e",
+                            "priv_key_tweak": "bf7336bdc02f624715aab385cc62b71f6f494bf8a7dd0fd621cfd365039c39d1",
+                            "signature": "e00ba3406cea12127896fbc198a9da889a4afcf3d66e46b3df0e7bb36de400a109442e5bbd005c3cc5ae30ae7d235ea111475ad621e1e2c27374fda906521c69"
+                        }
+                    ]
+                }
+            }
+        ]
+    },
+    {
+        "comment": "Single recipient: taproot only inputs with even y-values",
+        "sending": [
+            {
+                "given": {
+                    "outpoints": [
+                        [
+                            "f4184fc596403b9d638783cf57adfe4c75c605f6356fbc91338530e9831e9e16",
+                            0
+                        ],
+                        [
+                            "a1075db55d416d3ca199f55b6084e2115b9345e16c5cf302fc80e9d5fbf5d48d",
+                            0
+                        ]
+                    ],
+                    "input_priv_keys": [
+                        [
+                            "eadc78165ff1f8ea94ad7cfdc54990738a4c53f6e0507b42154201b8e5dff3b1",
+                            true
+                        ],
+                        [
+                            "fc8716a97a48ba9a05a98ae47b5cd201a25a7fd5d8b73c203c5f7b6b6b3b6ad7",
+                            true
+                        ]
+                    ],
+                    "recipients": [
+                        [
+                            "sp1qqgste7k9hx0qftg6qmwlkqtwuy6cycyavzmzj85c6qdfhjdpdjtdgqjuexzk6murw56suy3e0rd2cgqvycxttddwsvgxe2usfpxumr70xc9pkqwv",
+                            1.0
+                        ]
+                    ]
+                },
+                "expected": {
+                    "outputs": [
+                        [
+                            "15d1dfe4403791509cf47f073be2eb3277decabe90da395e63b1f49a09fe965e",
+                            1.0
+                        ]
+                    ]
+                }
+            }
+        ],
+        "receiving": [
+            {
+                "supports_labels": false,
+                "given": {
+                    "outpoints": [
+                        [
+                            "f4184fc596403b9d638783cf57adfe4c75c605f6356fbc91338530e9831e9e16",
+                            0
+                        ],
+                        [
+                            "a1075db55d416d3ca199f55b6084e2115b9345e16c5cf302fc80e9d5fbf5d48d",
+                            0
+                        ]
+                    ],
+                    "input_pub_keys": [
+                        "5a1e61f898173040e20616d43e9f496fba90338a39faa1ed98fcbaeee4dd9be5",
+                        "782eeb913431ca6e9b8c2fd80a5f72ed2024ef72a3c6fb10263c379937323338"
+                    ],
+                    "bip32_seed": "f00dbabe",
+                    "scan_priv_key": "0f694e068028a717f8af6b9411f9a133dd3565258714cc226594b34db90c1f2c",
+                    "spend_priv_key": "9d6ad855ce3417ef84e836892e5a56392bfba05fa5d97ccea30e266f540e08b3",
+                    "labels": {},
+                    "outputs": [
+                        "15d1dfe4403791509cf47f073be2eb3277decabe90da395e63b1f49a09fe965e"
+                    ]
+                },
+                "expected": {
+                    "addresses": [
+                        "sp1qqgste7k9hx0qftg6qmwlkqtwuy6cycyavzmzj85c6qdfhjdpdjtdgqjuexzk6murw56suy3e0rd2cgqvycxttddwsvgxe2usfpxumr70xc9pkqwv"
+                    ],
+                    "outputs": [
+                        {
+                            "pub_key": "15d1dfe4403791509cf47f073be2eb3277decabe90da395e63b1f49a09fe965e",
+                            "priv_key_tweak": "0734de077e436e8f6f125e16287cb60dead8ebddc8532be3589ba27156f1add2",
+                            "signature": "d743170ded6bc695f2997caed9886deb7ddc2e0e11d5f1493d6d7e498e8686f94c393c5d20eceb700a4c2035271196897a83fe1658414c38da07e0e4af00fd0a"
+                        }
+                    ]
+                }
+            }
+        ]
+    },
+    {
+        "comment": "Single recipient: taproot only with mixed even/odd y-values",
+        "sending": [
+            {
+                "given": {
+                    "outpoints": [
+                        [
+                            "f4184fc596403b9d638783cf57adfe4c75c605f6356fbc91338530e9831e9e16",
+                            0
+                        ],
+                        [
+                            "a1075db55d416d3ca199f55b6084e2115b9345e16c5cf302fc80e9d5fbf5d48d",
+                            0
+                        ]
+                    ],
+                    "input_priv_keys": [
+                        [
+                            "eadc78165ff1f8ea94ad7cfdc54990738a4c53f6e0507b42154201b8e5dff3b1",
+                            true
+                        ],
+                        [
+                            "0378e95685b74565fa56751b84a32dfd18545d10d691641b8372e32164fad66a",
+                            true
+                        ]
+                    ],
+                    "recipients": [
+                        [
+                            "sp1qqgste7k9hx0qftg6qmwlkqtwuy6cycyavzmzj85c6qdfhjdpdjtdgqjuexzk6murw56suy3e0rd2cgqvycxttddwsvgxe2usfpxumr70xc9pkqwv",
+                            1.0
+                        ]
+                    ]
+                },
+                "expected": {
+                    "outputs": [
+                        [
+                            "15d1dfe4403791509cf47f073be2eb3277decabe90da395e63b1f49a09fe965e",
+                            1.0
+                        ]
+                    ]
+                }
+            }
+        ],
+        "receiving": [
+            {
+                "supports_labels": false,
+                "given": {
+                    "outpoints": [
+                        [
+                            "f4184fc596403b9d638783cf57adfe4c75c605f6356fbc91338530e9831e9e16",
+                            0
+                        ],
+                        [
+                            "a1075db55d416d3ca199f55b6084e2115b9345e16c5cf302fc80e9d5fbf5d48d",
+                            0
+                        ]
+                    ],
+                    "input_pub_keys": [
+                        "5a1e61f898173040e20616d43e9f496fba90338a39faa1ed98fcbaeee4dd9be5",
+                        "782eeb913431ca6e9b8c2fd80a5f72ed2024ef72a3c6fb10263c379937323338"
+                    ],
+                    "bip32_seed": "f00dbabe",
+                    "scan_priv_key": "0f694e068028a717f8af6b9411f9a133dd3565258714cc226594b34db90c1f2c",
+                    "spend_priv_key": "9d6ad855ce3417ef84e836892e5a56392bfba05fa5d97ccea30e266f540e08b3",
+                    "labels": {},
+                    "outputs": [
+                        "15d1dfe4403791509cf47f073be2eb3277decabe90da395e63b1f49a09fe965e"
+                    ]
+                },
+                "expected": {
+                    "addresses": [
+                        "sp1qqgste7k9hx0qftg6qmwlkqtwuy6cycyavzmzj85c6qdfhjdpdjtdgqjuexzk6murw56suy3e0rd2cgqvycxttddwsvgxe2usfpxumr70xc9pkqwv"
+                    ],
+                    "outputs": [
+                        {
+                            "pub_key": "15d1dfe4403791509cf47f073be2eb3277decabe90da395e63b1f49a09fe965e",
+                            "priv_key_tweak": "0734de077e436e8f6f125e16287cb60dead8ebddc8532be3589ba27156f1add2",
+                            "signature": "d743170ded6bc695f2997caed9886deb7ddc2e0e11d5f1493d6d7e498e8686f94c393c5d20eceb700a4c2035271196897a83fe1658414c38da07e0e4af00fd0a"
+                        }
+                    ]
+                }
+            }
+        ]
+    },
+    {
+        "comment": "Single recipient: taproot input with even y-value and non-taproot input",
+        "sending": [
+            {
+                "given": {
+                    "outpoints": [
+                        [
+                            "f4184fc596403b9d638783cf57adfe4c75c605f6356fbc91338530e9831e9e16",
+                            0
+                        ],
+                        [
+                            "a1075db55d416d3ca199f55b6084e2115b9345e16c5cf302fc80e9d5fbf5d48d",
+                            0
+                        ]
+                    ],
+                    "input_priv_keys": [
+                        [
+                            "eadc78165ff1f8ea94ad7cfdc54990738a4c53f6e0507b42154201b8e5dff3b1",
+                            true
+                        ],
+                        [
+                            "8d4751f6e8a3586880fb66c19ae277969bd5aa06f61c4ee2f1e2486efdf666d3",
+                            false
+                        ]
+                    ],
+                    "recipients": [
+                        [
+                            "sp1qqgste7k9hx0qftg6qmwlkqtwuy6cycyavzmzj85c6qdfhjdpdjtdgqjuexzk6murw56suy3e0rd2cgqvycxttddwsvgxe2usfpxumr70xc9pkqwv",
+                            1.0
+                        ]
+                    ]
+                },
+                "expected": {
+                    "outputs": [
+                        [
+                            "2b4ff8e5bc608cbdd12117171e7d265b6882ad597559caf67b5ecfaf15301dd0",
+                            1.0
+                        ]
+                    ]
+                }
+            }
+        ],
+        "receiving": [
+            {
+                "supports_labels": false,
+                "given": {
+                    "outpoints": [
+                        [
+                            "f4184fc596403b9d638783cf57adfe4c75c605f6356fbc91338530e9831e9e16",
+                            0
+                        ],
+                        [
+                            "a1075db55d416d3ca199f55b6084e2115b9345e16c5cf302fc80e9d5fbf5d48d",
+                            0
+                        ]
+                    ],
+                    "input_pub_keys": [
+                        "5a1e61f898173040e20616d43e9f496fba90338a39faa1ed98fcbaeee4dd9be5",
+                        "03e0ec4f64b3fa2e463ccfcf4e856e37d5e1e20275bc89ec1def9eb098eff1f85d"
+                    ],
+                    "bip32_seed": "f00dbabe",
+                    "scan_priv_key": "0f694e068028a717f8af6b9411f9a133dd3565258714cc226594b34db90c1f2c",
+                    "spend_priv_key": "9d6ad855ce3417ef84e836892e5a56392bfba05fa5d97ccea30e266f540e08b3",
+                    "labels": {},
+                    "outputs": [
+                        "2b4ff8e5bc608cbdd12117171e7d265b6882ad597559caf67b5ecfaf15301dd0"
+                    ]
+                },
+                "expected": {
+                    "addresses": [
+                        "sp1qqgste7k9hx0qftg6qmwlkqtwuy6cycyavzmzj85c6qdfhjdpdjtdgqjuexzk6murw56suy3e0rd2cgqvycxttddwsvgxe2usfpxumr70xc9pkqwv"
+                    ],
+                    "outputs": [
+                        {
+                            "pub_key": "2b4ff8e5bc608cbdd12117171e7d265b6882ad597559caf67b5ecfaf15301dd0",
+                            "priv_key_tweak": "17d93733d2acd8388279c24dc4413483802378c99f266f5961ac3338c5146861",
+                            "signature": "7f8f909460c0357a2c1c784e92967e888c6b63ff799db3ce22e8acc715a42ab9177b9db2237d76db60e72bc30c827008266062506cd57f93f9b872529bd50376"
+                        }
+                    ]
+                }
+            }
+        ]
+    },
+    {
+        "comment": "Single recipient: taproot input with odd y-value and non-taproot input",
+        "sending": [
+            {
+                "given": {
+                    "outpoints": [
+                        [
+                            "f4184fc596403b9d638783cf57adfe4c75c605f6356fbc91338530e9831e9e16",
+                            0
+                        ],
+                        [
+                            "a1075db55d416d3ca199f55b6084e2115b9345e16c5cf302fc80e9d5fbf5d48d",
+                            0
+                        ]
+                    ],
+                    "input_priv_keys": [
+                        [
+                            "0378e95685b74565fa56751b84a32dfd18545d10d691641b8372e32164fad66a",
+                            true
+                        ],
+                        [
+                            "8d4751f6e8a3586880fb66c19ae277969bd5aa06f61c4ee2f1e2486efdf666d3",
+                            false
+                        ]
+                    ],
+                    "recipients": [
+                        [
+                            "sp1qqgste7k9hx0qftg6qmwlkqtwuy6cycyavzmzj85c6qdfhjdpdjtdgqjuexzk6murw56suy3e0rd2cgqvycxttddwsvgxe2usfpxumr70xc9pkqwv",
+                            1.0
+                        ]
+                    ]
+                },
+                "expected": {
+                    "outputs": [
+                        [
+                            "75f501f319db549aaa613717bd7af44da566d4d859b67fe436946564fafc47a3",
+                            1.0
+                        ]
+                    ]
+                }
+            }
+        ],
+        "receiving": [
+            {
+                "supports_labels": false,
+                "given": {
+                    "outpoints": [
+                        [
+                            "f4184fc596403b9d638783cf57adfe4c75c605f6356fbc91338530e9831e9e16",
+                            0
+                        ],
+                        [
+                            "a1075db55d416d3ca199f55b6084e2115b9345e16c5cf302fc80e9d5fbf5d48d",
+                            0
+                        ]
+                    ],
+                    "input_pub_keys": [
+                        "782eeb913431ca6e9b8c2fd80a5f72ed2024ef72a3c6fb10263c379937323338",
+                        "03e0ec4f64b3fa2e463ccfcf4e856e37d5e1e20275bc89ec1def9eb098eff1f85d"
+                    ],
+                    "bip32_seed": "f00dbabe",
+                    "scan_priv_key": "0f694e068028a717f8af6b9411f9a133dd3565258714cc226594b34db90c1f2c",
+                    "spend_priv_key": "9d6ad855ce3417ef84e836892e5a56392bfba05fa5d97ccea30e266f540e08b3",
+                    "labels": {},
+                    "outputs": [
+                        "75f501f319db549aaa613717bd7af44da566d4d859b67fe436946564fafc47a3"
+                    ]
+                },
+                "expected": {
+                    "addresses": [
+                        "sp1qqgste7k9hx0qftg6qmwlkqtwuy6cycyavzmzj85c6qdfhjdpdjtdgqjuexzk6murw56suy3e0rd2cgqvycxttddwsvgxe2usfpxumr70xc9pkqwv"
+                    ],
+                    "outputs": [
+                        {
+                            "pub_key": "75f501f319db549aaa613717bd7af44da566d4d859b67fe436946564fafc47a3",
+                            "priv_key_tweak": "619a5a59a16d4a8e857ef48e63ef7c8195c858191d4e826205e8438ab70d059e",
+                            "signature": "ba2e40de3b3acbc97d282f2d09b9c79936de109710e8d4139409964346f1221c3d4c823a1ee0a946f98b0ce644d136fbc5ea22cd73736fe05475174b25c01e62"
+                        }
+                    ]
+                }
+            }
+        ]
+    },
+    {
+        "comment": "Multiple outputs: multiple outputs, same recipient",
+        "sending": [
+            {
+                "given": {
+                    "outpoints": [
+                        [
+                            "f4184fc596403b9d638783cf57adfe4c75c605f6356fbc91338530e9831e9e16",
+                            0
+                        ],
+                        [
+                            "a1075db55d416d3ca199f55b6084e2115b9345e16c5cf302fc80e9d5fbf5d48d",
+                            0
+                        ]
+                    ],
+                    "input_priv_keys": [
+                        [
+                            "eadc78165ff1f8ea94ad7cfdc54990738a4c53f6e0507b42154201b8e5dff3b1",
+                            false
+                        ],
+                        [
+                            "0378e95685b74565fa56751b84a32dfd18545d10d691641b8372e32164fad66a",
+                            false
+                        ]
+                    ],
+                    "recipients": [
+                        [
+                            "sp1qqgste7k9hx0qftg6qmwlkqtwuy6cycyavzmzj85c6qdfhjdpdjtdgqjuexzk6murw56suy3e0rd2cgqvycxttddwsvgxe2usfpxumr70xc9pkqwv",
+                            2.0
+                        ],
+                        [
+                            "sp1qqgste7k9hx0qftg6qmwlkqtwuy6cycyavzmzj85c6qdfhjdpdjtdgqjuexzk6murw56suy3e0rd2cgqvycxttddwsvgxe2usfpxumr70xc9pkqwv",
+                            3.0
+                        ]
+                    ]
+                },
+                "expected": {
+                    "outputs": [
+                        [
+                            "64f1c7e8992352d18cdbca600b9e1c3a6025050d56a3e1cc833222e4f3b59e18",
+                            2.0
+                        ],
+                        [
+                            "0a48c6ccc1d516e8244dc0153dc88db45f8f264357667c2057a29ca3c2445d09",
+                            3.0
+                        ]
+                    ]
+                }
+            }
+        ],
+        "receiving": [
+            {
+                "supports_labels": false,
+                "given": {
+                    "outpoints": [
+                        [
+                            "f4184fc596403b9d638783cf57adfe4c75c605f6356fbc91338530e9831e9e16",
+                            0
+                        ],
+                        [
+                            "a1075db55d416d3ca199f55b6084e2115b9345e16c5cf302fc80e9d5fbf5d48d",
+                            0
+                        ]
+                    ],
+                    "input_pub_keys": [
+                        "025a1e61f898173040e20616d43e9f496fba90338a39faa1ed98fcbaeee4dd9be5",
+                        "03782eeb913431ca6e9b8c2fd80a5f72ed2024ef72a3c6fb10263c379937323338"
+                    ],
+                    "bip32_seed": "f00dbabe",
+                    "scan_priv_key": "0f694e068028a717f8af6b9411f9a133dd3565258714cc226594b34db90c1f2c",
+                    "spend_priv_key": "9d6ad855ce3417ef84e836892e5a56392bfba05fa5d97ccea30e266f540e08b3",
+                    "labels": {},
+                    "outputs": [
+                        "64f1c7e8992352d18cdbca600b9e1c3a6025050d56a3e1cc833222e4f3b59e18",
+                        "0a48c6ccc1d516e8244dc0153dc88db45f8f264357667c2057a29ca3c2445d09",
+                        "c58e121044b23cba9b4695052229a9fd9e044b579f92864eb886ae7c99b021c9",
+                        "4b15b75f3f184328c4a2f7c79357481ed06cf3b6f95512d5ed946fdc0b60d62b"
+                    ]
+                },
+                "expected": {
+                    "addresses": [
+                        "sp1qqgste7k9hx0qftg6qmwlkqtwuy6cycyavzmzj85c6qdfhjdpdjtdgqjuexzk6murw56suy3e0rd2cgqvycxttddwsvgxe2usfpxumr70xc9pkqwv"
+                    ],
+                    "outputs": [
+                        {
+                            "pub_key": "64f1c7e8992352d18cdbca600b9e1c3a6025050d56a3e1cc833222e4f3b59e18",
+                            "priv_key_tweak": "96439446f13ddaab2c5bc5a59a08992fd9d33bf8563c8a1b362730f4dc022e30",
+                            "signature": "3f6226feb9e4cafc0bdab8c9cfe085885308f3708c222bcec6cf26467685d897f51597abe39d1d279708e63513c7be23daed78607a98837060950493de188645"
+                        },
+                        {
+                            "pub_key": "0a48c6ccc1d516e8244dc0153dc88db45f8f264357667c2057a29ca3c2445d09",
+                            "priv_key_tweak": "d39df91bd0e7825bfa1d30096febc5bf6fa7da79d7f25b7b4bea9538cc9a9f7f",
+                            "signature": "be5f139f6eaad2d5eb75c6e307defb29925e16d55dbbc12872b0ab6aca38959c0c6a8f3f72bf82e3deb226cb539e117f9db4b04a5efb4e2eb01a86374f5baa12"
+                        }
+                    ]
+                }
+            }
+        ]
+    },
+    {
+        "comment": "Multiple outputs: multiple outputs, multiple recipients",
+        "sending": [
+            {
+                "given": {
+                    "outpoints": [
+                        [
+                            "f4184fc596403b9d638783cf57adfe4c75c605f6356fbc91338530e9831e9e16",
+                            0
+                        ],
+                        [
+                            "a1075db55d416d3ca199f55b6084e2115b9345e16c5cf302fc80e9d5fbf5d48d",
+                            0
+                        ]
+                    ],
+                    "input_priv_keys": [
+                        [
+                            "eadc78165ff1f8ea94ad7cfdc54990738a4c53f6e0507b42154201b8e5dff3b1",
+                            false
+                        ],
+                        [
+                            "0378e95685b74565fa56751b84a32dfd18545d10d691641b8372e32164fad66a",
+                            false
+                        ]
+                    ],
+                    "recipients": [
+                        [
+                            "sp1qqgste7k9hx0qftg6qmwlkqtwuy6cycyavzmzj85c6qdfhjdpdjtdgqjuexzk6murw56suy3e0rd2cgqvycxttddwsvgxe2usfpxumr70xc9pkqwv",
+                            2.0
+                        ],
+                        [
+                            "sp1qqgste7k9hx0qftg6qmwlkqtwuy6cycyavzmzj85c6qdfhjdpdjtdgqjuexzk6murw56suy3e0rd2cgqvycxttddwsvgxe2usfpxumr70xc9pkqwv",
+                            3.0
+                        ],
+                        [
+                            "sp1qqgrz6j0lcqnc04vxccydl0kpsj4frfje0ktmgcl2t346hkw30226xqupawdf48k8882j0strrvcmgg2kdawz53a54dd376ngdhak364hzcmynqtn",
+                            4.0
+                        ],
+                        [
+                            "sp1qqgrz6j0lcqnc04vxccydl0kpsj4frfje0ktmgcl2t346hkw30226xqupawdf48k8882j0strrvcmgg2kdawz53a54dd376ngdhak364hzcmynqtn",
+                            5.0
+                        ]
+                    ]
+                },
+                "expected": {
+                    "outputs": [
+                        [
+                            "64f1c7e8992352d18cdbca600b9e1c3a6025050d56a3e1cc833222e4f3b59e18",
+                            2.0
+                        ],
+                        [
+                            "0a48c6ccc1d516e8244dc0153dc88db45f8f264357667c2057a29ca3c2445d09",
+                            3.0
+                        ],
+                        [
+                            "c58e121044b23cba9b4695052229a9fd9e044b579f92864eb886ae7c99b021c9",
+                            4.0
+                        ],
+                        [
+                            "4b15b75f3f184328c4a2f7c79357481ed06cf3b6f95512d5ed946fdc0b60d62b",
+                            5.0
+                        ]
+                    ]
+                }
+            }
+        ],
+        "receiving": [
+            {
+                "supports_labels": false,
+                "given": {
+                    "outpoints": [
+                        [
+                            "f4184fc596403b9d638783cf57adfe4c75c605f6356fbc91338530e9831e9e16",
+                            0
+                        ],
+                        [
+                            "a1075db55d416d3ca199f55b6084e2115b9345e16c5cf302fc80e9d5fbf5d48d",
+                            0
+                        ]
+                    ],
+                    "input_pub_keys": [
+                        "025a1e61f898173040e20616d43e9f496fba90338a39faa1ed98fcbaeee4dd9be5",
+                        "03782eeb913431ca6e9b8c2fd80a5f72ed2024ef72a3c6fb10263c379937323338"
+                    ],
+                    "bip32_seed": "f00dbabe",
+                    "scan_priv_key": "0f694e068028a717f8af6b9411f9a133dd3565258714cc226594b34db90c1f2c",
+                    "spend_priv_key": "9d6ad855ce3417ef84e836892e5a56392bfba05fa5d97ccea30e266f540e08b3",
+                    "labels": {},
+                    "outputs": [
+                        "64f1c7e8992352d18cdbca600b9e1c3a6025050d56a3e1cc833222e4f3b59e18",
+                        "0a48c6ccc1d516e8244dc0153dc88db45f8f264357667c2057a29ca3c2445d09",
+                        "c58e121044b23cba9b4695052229a9fd9e044b579f92864eb886ae7c99b021c9",
+                        "4b15b75f3f184328c4a2f7c79357481ed06cf3b6f95512d5ed946fdc0b60d62b"
+                    ]
+                },
+                "expected": {
+                    "addresses": [
+                        "sp1qqgste7k9hx0qftg6qmwlkqtwuy6cycyavzmzj85c6qdfhjdpdjtdgqjuexzk6murw56suy3e0rd2cgqvycxttddwsvgxe2usfpxumr70xc9pkqwv"
+                    ],
+                    "outputs": [
+                        {
+                            "pub_key": "64f1c7e8992352d18cdbca600b9e1c3a6025050d56a3e1cc833222e4f3b59e18",
+                            "priv_key_tweak": "96439446f13ddaab2c5bc5a59a08992fd9d33bf8563c8a1b362730f4dc022e30",
+                            "signature": "3f6226feb9e4cafc0bdab8c9cfe085885308f3708c222bcec6cf26467685d897f51597abe39d1d279708e63513c7be23daed78607a98837060950493de188645"
+                        },
+                        {
+                            "pub_key": "0a48c6ccc1d516e8244dc0153dc88db45f8f264357667c2057a29ca3c2445d09",
+                            "priv_key_tweak": "d39df91bd0e7825bfa1d30096febc5bf6fa7da79d7f25b7b4bea9538cc9a9f7f",
+                            "signature": "be5f139f6eaad2d5eb75c6e307defb29925e16d55dbbc12872b0ab6aca38959c0c6a8f3f72bf82e3deb226cb539e117f9db4b04a5efb4e2eb01a86374f5baa12"
+                        }
+                    ]
+                }
+            },
+            {
+                "supports_labels": false,
+                "given": {
+                    "outpoints": [
+                        [
+                            "f4184fc596403b9d638783cf57adfe4c75c605f6356fbc91338530e9831e9e16",
+                            0
+                        ],
+                        [
+                            "a1075db55d416d3ca199f55b6084e2115b9345e16c5cf302fc80e9d5fbf5d48d",
+                            0
+                        ]
+                    ],
+                    "input_pub_keys": [
+                        "025a1e61f898173040e20616d43e9f496fba90338a39faa1ed98fcbaeee4dd9be5",
+                        "03782eeb913431ca6e9b8c2fd80a5f72ed2024ef72a3c6fb10263c379937323338"
+                    ],
+                    "bip32_seed": "decafbad",
+                    "scan_priv_key": "060b751d7892149006ed7b98606955a29fe284a1e900070c0971f5fb93dbf422",
+                    "spend_priv_key": "9902c3c56e84002a7cd410113a9ab21d142be7f53cf5200720bb01314c5eb920",
+                    "labels": {},
+                    "outputs": [
+                        "64f1c7e8992352d18cdbca600b9e1c3a6025050d56a3e1cc833222e4f3b59e18",
+                        "0a48c6ccc1d516e8244dc0153dc88db45f8f264357667c2057a29ca3c2445d09",
+                        "c58e121044b23cba9b4695052229a9fd9e044b579f92864eb886ae7c99b021c9",
+                        "4b15b75f3f184328c4a2f7c79357481ed06cf3b6f95512d5ed946fdc0b60d62b"
+                    ]
+                },
+                "expected": {
+                    "addresses": [
+                        "sp1qqgrz6j0lcqnc04vxccydl0kpsj4frfje0ktmgcl2t346hkw30226xqupawdf48k8882j0strrvcmgg2kdawz53a54dd376ngdhak364hzcmynqtn"
+                    ],
+                    "outputs": [
+                        {
+                            "pub_key": "c58e121044b23cba9b4695052229a9fd9e044b579f92864eb886ae7c99b021c9",
+                            "priv_key_tweak": "567710d07bdaacc8de3f1cec467bcb162ed7daa6b901b59af257bcd7e39dffcf",
+                            "signature": "d675fd6f55f42b61c8797c80d46048cfca5125bcef06e3a0ff555ace0e8f6d84da9b6f473b559376afd5ee11dc63c4415dc565f8272d2b673d39759f29c0d56a"
+                        },
+                        {
+                            "pub_key": "4b15b75f3f184328c4a2f7c79357481ed06cf3b6f95512d5ed946fdc0b60d62b",
+                            "priv_key_tweak": "25dd11163a9a2853709c4c837aafb3347e2eaa875cf4c5170e2a3663879f4c58",
+                            "signature": "ab872ee64623cf1ddb646c65159c09bc69cd64c6b60767a94934e12ec074f0fa7c9e4cc6a9bca2ec6592e4d64636a07fcfd71c622619c3bf46c5a2816aeb3456"
+                        }
+                    ]
+                }
+            }
+        ]
+    },
+    {
+        "comment": "Receiving with labels: label with even parity",
+        "sending": [
+            {
+                "given": {
+                    "outpoints": [
+                        [
+                            "f4184fc596403b9d638783cf57adfe4c75c605f6356fbc91338530e9831e9e16",
+                            0
+                        ],
+                        [
+                            "a1075db55d416d3ca199f55b6084e2115b9345e16c5cf302fc80e9d5fbf5d48d",
+                            0
+                        ]
+                    ],
+                    "input_priv_keys": [
+                        [
+                            "eadc78165ff1f8ea94ad7cfdc54990738a4c53f6e0507b42154201b8e5dff3b1",
+                            false
+                        ],
+                        [
+                            "0378e95685b74565fa56751b84a32dfd18545d10d691641b8372e32164fad66a",
+                            false
+                        ]
+                    ],
+                    "recipients": [
+                        [
+                            "sp1qqgste7k9hx0qftg6qmwlkqtwuy6cycyavzmzj85c6qdfhjdpdjtdgqhmem6grvs4nacsu0v5v5mjs934j7qfgkdkj8c95gyuru3tjpulvcwky2dz",
+                            1.0
+                        ]
+                    ]
+                },
+                "expected": {
+                    "outputs": [
+                        [
+                            "2cbceeab2a4982841eb7dc34b8b4f19c04bf3bc083ebf984f5664366778eb50f",
+                            1.0
+                        ]
+                    ]
+                }
+            }
+        ],
+        "receiving": [
+            {
+                "supports_labels": true,
+                "given": {
+                    "outpoints": [
+                        [
+                            "f4184fc596403b9d638783cf57adfe4c75c605f6356fbc91338530e9831e9e16",
+                            0
+                        ],
+                        [
+                            "a1075db55d416d3ca199f55b6084e2115b9345e16c5cf302fc80e9d5fbf5d48d",
+                            0
+                        ]
+                    ],
+                    "input_pub_keys": [
+                        "025a1e61f898173040e20616d43e9f496fba90338a39faa1ed98fcbaeee4dd9be5",
+                        "03782eeb913431ca6e9b8c2fd80a5f72ed2024ef72a3c6fb10263c379937323338"
+                    ],
+                    "bip32_seed": "f00dbabe",
+                    "scan_priv_key": "0f694e068028a717f8af6b9411f9a133dd3565258714cc226594b34db90c1f2c",
+                    "spend_priv_key": "9d6ad855ce3417ef84e836892e5a56392bfba05fa5d97ccea30e266f540e08b3",
+                    "labels": {
+                        "02c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5": "0000000000000000000000000000000000000000000000000000000000000002",
+                        "02f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9": "0000000000000000000000000000000000000000000000000000000000000003",
+                        "03348b4f5feb64b557dac8cfa10044bdc2094fca9147163bf514f68687e0d1dba6": "00000000000000000000000000000000000000000000000000000000000f4779"
+                    },
+                    "outputs": [
+                        "2cbceeab2a4982841eb7dc34b8b4f19c04bf3bc083ebf984f5664366778eb50f"
+                    ]
+                },
+                "expected": {
+                    "addresses": [
+                        "sp1qqgste7k9hx0qftg6qmwlkqtwuy6cycyavzmzj85c6qdfhjdpdjtdgqjuexzk6murw56suy3e0rd2cgqvycxttddwsvgxe2usfpxumr70xc9pkqwv",
+                        "sp1qqgste7k9hx0qftg6qmwlkqtwuy6cycyavzmzj85c6qdfhjdpdjtdgqhmem6grvs4nacsu0v5v5mjs934j7qfgkdkj8c95gyuru3tjpulvcwky2dz",
+                        "sp1qqgste7k9hx0qftg6qmwlkqtwuy6cycyavzmzj85c6qdfhjdpdjtdgqc389f45lq7jyqt8jxq6fkskfukr2tlruf6w8cpcx2krntwe4fr9ykagp3j",
+                        "sp1qqgste7k9hx0qftg6qmwlkqtwuy6cycyavzmzj85c6qdfhjdpdjtdgq4umqa5feskydh9xadc9jlc22c89tu0apcv72u2vkuwtsrgzf0uesq45zq9"
+                    ],
+                    "outputs": [
+                        {
+                            "pub_key": "2cbceeab2a4982841eb7dc34b8b4f19c04bf3bc083ebf984f5664366778eb50f",
+                            "priv_key_tweak": "96439446f13ddaab2c5bc5a59a08992fd9d33bf8563c8a1b362730f4dc022e32",
+                            "signature": "0fa1b43afde9a03901dda91a0bd66fc82b6452c14a20718dc87dc70d4cedd9aeadf7c4c96116b8053c4aa113e26cea2fb64f8c408a8e8bc6e4fc9f6a06672b95"
+                        }
+                    ]
+                }
+            }
+        ]
+    },
+    {
+        "comment": "Receiving with labels: label with odd parity",
+        "sending": [
+            {
+                "given": {
+                    "outpoints": [
+                        [
+                            "f4184fc596403b9d638783cf57adfe4c75c605f6356fbc91338530e9831e9e16",
+                            0
+                        ],
+                        [
+                            "a1075db55d416d3ca199f55b6084e2115b9345e16c5cf302fc80e9d5fbf5d48d",
+                            0
+                        ]
+                    ],
+                    "input_priv_keys": [
+                        [
+                            "eadc78165ff1f8ea94ad7cfdc54990738a4c53f6e0507b42154201b8e5dff3b1",
+                            false
+                        ],
+                        [
+                            "0378e95685b74565fa56751b84a32dfd18545d10d691641b8372e32164fad66a",
+                            false
+                        ]
+                    ],
+                    "recipients": [
+                        [
+                            "sp1qqgste7k9hx0qftg6qmwlkqtwuy6cycyavzmzj85c6qdfhjdpdjtdgqc389f45lq7jyqt8jxq6fkskfukr2tlruf6w8cpcx2krntwe4fr9ykagp3j",
+                            1.0
+                        ]
+                    ]
+                },
+                "expected": {
+                    "outputs": [
+                        [
+                            "6b4455de119f51bf4d4a12dea555f14a5dc2c1369af5fba4871c5367264c028d",
+                            1.0
+                        ]
+                    ]
+                }
+            }
+        ],
+        "receiving": [
+            {
+                "supports_labels": true,
+                "given": {
+                    "outpoints": [
+                        [
+                            "f4184fc596403b9d638783cf57adfe4c75c605f6356fbc91338530e9831e9e16",
+                            0
+                        ],
+                        [
+                            "a1075db55d416d3ca199f55b6084e2115b9345e16c5cf302fc80e9d5fbf5d48d",
+                            0
+                        ]
+                    ],
+                    "input_pub_keys": [
+                        "025a1e61f898173040e20616d43e9f496fba90338a39faa1ed98fcbaeee4dd9be5",
+                        "03782eeb913431ca6e9b8c2fd80a5f72ed2024ef72a3c6fb10263c379937323338"
+                    ],
+                    "bip32_seed": "f00dbabe",
+                    "scan_priv_key": "0f694e068028a717f8af6b9411f9a133dd3565258714cc226594b34db90c1f2c",
+                    "spend_priv_key": "9d6ad855ce3417ef84e836892e5a56392bfba05fa5d97ccea30e266f540e08b3",
+                    "labels": {
+                        "02c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5": "0000000000000000000000000000000000000000000000000000000000000002",
+                        "02f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9": "0000000000000000000000000000000000000000000000000000000000000003",
+                        "03348b4f5feb64b557dac8cfa10044bdc2094fca9147163bf514f68687e0d1dba6": "00000000000000000000000000000000000000000000000000000000000f4779"
+                    },
+                    "outputs": [
+                        "6b4455de119f51bf4d4a12dea555f14a5dc2c1369af5fba4871c5367264c028d"
+                    ]
+                },
+                "expected": {
+                    "addresses": [
+                        "sp1qqgste7k9hx0qftg6qmwlkqtwuy6cycyavzmzj85c6qdfhjdpdjtdgqjuexzk6murw56suy3e0rd2cgqvycxttddwsvgxe2usfpxumr70xc9pkqwv",
+                        "sp1qqgste7k9hx0qftg6qmwlkqtwuy6cycyavzmzj85c6qdfhjdpdjtdgqhmem6grvs4nacsu0v5v5mjs934j7qfgkdkj8c95gyuru3tjpulvcwky2dz",
+                        "sp1qqgste7k9hx0qftg6qmwlkqtwuy6cycyavzmzj85c6qdfhjdpdjtdgqc389f45lq7jyqt8jxq6fkskfukr2tlruf6w8cpcx2krntwe4fr9ykagp3j",
+                        "sp1qqgste7k9hx0qftg6qmwlkqtwuy6cycyavzmzj85c6qdfhjdpdjtdgq4umqa5feskydh9xadc9jlc22c89tu0apcv72u2vkuwtsrgzf0uesq45zq9"
+                    ],
+                    "outputs": [
+                        {
+                            "pub_key": "6b4455de119f51bf4d4a12dea555f14a5dc2c1369af5fba4871c5367264c028d",
+                            "priv_key_tweak": "96439446f13ddaab2c5bc5a59a08992fd9d33bf8563c8a1b362730f4dc022e33",
+                            "signature": "b4ea01f7f47bcdf131b5a3aa3a1c848faae75e661d63bfff84c230bcc96313d0b443b9b3a76718a7474d51994395739bc6041caabe98133e3697412e07e19c0a"
+                        }
+                    ]
+                }
+            }
+        ]
+    },
+    {
+        "comment": "Receiving with labels: large label integer",
+        "sending": [
+            {
+                "given": {
+                    "outpoints": [
+                        [
+                            "f4184fc596403b9d638783cf57adfe4c75c605f6356fbc91338530e9831e9e16",
+                            0
+                        ],
+                        [
+                            "a1075db55d416d3ca199f55b6084e2115b9345e16c5cf302fc80e9d5fbf5d48d",
+                            0
+                        ]
+                    ],
+                    "input_priv_keys": [
+                        [
+                            "eadc78165ff1f8ea94ad7cfdc54990738a4c53f6e0507b42154201b8e5dff3b1",
+                            false
+                        ],
+                        [
+                            "0378e95685b74565fa56751b84a32dfd18545d10d691641b8372e32164fad66a",
+                            false
+                        ]
+                    ],
+                    "recipients": [
+                        [
+                            "sp1qqgste7k9hx0qftg6qmwlkqtwuy6cycyavzmzj85c6qdfhjdpdjtdgq4umqa5feskydh9xadc9jlc22c89tu0apcv72u2vkuwtsrgzf0uesq45zq9",
+                            1.0
+                        ]
+                    ]
+                },
+                "expected": {
+                    "outputs": [
+                        [
+                            "c3473bfcbe5e4d20d0790ae91f1b339bc15b46de64ca068d140118d0e325b849",
+                            1.0
+                        ]
+                    ]
+                }
+            }
+        ],
+        "receiving": [
+            {
+                "supports_labels": true,
+                "given": {
+                    "outpoints": [
+                        [
+                            "f4184fc596403b9d638783cf57adfe4c75c605f6356fbc91338530e9831e9e16",
+                            0
+                        ],
+                        [
+                            "a1075db55d416d3ca199f55b6084e2115b9345e16c5cf302fc80e9d5fbf5d48d",
+                            0
+                        ]
+                    ],
+                    "input_pub_keys": [
+                        "025a1e61f898173040e20616d43e9f496fba90338a39faa1ed98fcbaeee4dd9be5",
+                        "03782eeb913431ca6e9b8c2fd80a5f72ed2024ef72a3c6fb10263c379937323338"
+                    ],
+                    "bip32_seed": "f00dbabe",
+                    "scan_priv_key": "0f694e068028a717f8af6b9411f9a133dd3565258714cc226594b34db90c1f2c",
+                    "spend_priv_key": "9d6ad855ce3417ef84e836892e5a56392bfba05fa5d97ccea30e266f540e08b3",
+                    "labels": {
+                        "02c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5": "0000000000000000000000000000000000000000000000000000000000000002",
+                        "02f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9": "0000000000000000000000000000000000000000000000000000000000000003",
+                        "03348b4f5feb64b557dac8cfa10044bdc2094fca9147163bf514f68687e0d1dba6": "00000000000000000000000000000000000000000000000000000000000f4779"
+                    },
+                    "outputs": [
+                        "c3473bfcbe5e4d20d0790ae91f1b339bc15b46de64ca068d140118d0e325b849"
+                    ]
+                },
+                "expected": {
+                    "addresses": [
+                        "sp1qqgste7k9hx0qftg6qmwlkqtwuy6cycyavzmzj85c6qdfhjdpdjtdgqjuexzk6murw56suy3e0rd2cgqvycxttddwsvgxe2usfpxumr70xc9pkqwv",
+                        "sp1qqgste7k9hx0qftg6qmwlkqtwuy6cycyavzmzj85c6qdfhjdpdjtdgqhmem6grvs4nacsu0v5v5mjs934j7qfgkdkj8c95gyuru3tjpulvcwky2dz",
+                        "sp1qqgste7k9hx0qftg6qmwlkqtwuy6cycyavzmzj85c6qdfhjdpdjtdgqc389f45lq7jyqt8jxq6fkskfukr2tlruf6w8cpcx2krntwe4fr9ykagp3j",
+                        "sp1qqgste7k9hx0qftg6qmwlkqtwuy6cycyavzmzj85c6qdfhjdpdjtdgq4umqa5feskydh9xadc9jlc22c89tu0apcv72u2vkuwtsrgzf0uesq45zq9"
+                    ],
+                    "outputs": [
+                        {
+                            "pub_key": "c3473bfcbe5e4d20d0790ae91f1b339bc15b46de64ca068d140118d0e325b849",
+                            "priv_key_tweak": "96439446f13ddaab2c5bc5a59a08992fd9d33bf8563c8a1b362730f4dc1175a9",
+                            "signature": "ab9f3684cb497951fd013444d35909ed10669691d9fa3ac0be57f874a4df9f43c67647c9f17528110d2df0ce41dd3c05c04f4624629f8758fff1060049dc7d6b"
+                        }
+                    ]
+                }
+            }
+        ]
+    },
+    {
+        "comment": "Multiple outputs with labels: un-labeled and labeled address; same recipient",
+        "sending": [
+            {
+                "given": {
+                    "outpoints": [
+                        [
+                            "f4184fc596403b9d638783cf57adfe4c75c605f6356fbc91338530e9831e9e16",
+                            0
+                        ],
+                        [
+                            "a1075db55d416d3ca199f55b6084e2115b9345e16c5cf302fc80e9d5fbf5d48d",
+                            0
+                        ]
+                    ],
+                    "input_priv_keys": [
+                        [
+                            "eadc78165ff1f8ea94ad7cfdc54990738a4c53f6e0507b42154201b8e5dff3b1",
+                            false
+                        ],
+                        [
+                            "0378e95685b74565fa56751b84a32dfd18545d10d691641b8372e32164fad66a",
+                            false
+                        ]
+                    ],
+                    "recipients": [
+                        [
+                            "sp1qqgste7k9hx0qftg6qmwlkqtwuy6cycyavzmzj85c6qdfhjdpdjtdgqjuexzk6murw56suy3e0rd2cgqvycxttddwsvgxe2usfpxumr70xc9pkqwv",
+                            1.0
+                        ],
+                        [
+                            "sp1qqgste7k9hx0qftg6qmwlkqtwuy6cycyavzmzj85c6qdfhjdpdjtdgqah4hxfsjdwyaeel4g8x2npkj7qlvf2692l5760z5ut0ggnlrhdzsy3cvsj",
+                            2.0
+                        ]
+                    ]
+                },
+                "expected": {
+                    "outputs": [
+                        [
+                            "64f1c7e8992352d18cdbca600b9e1c3a6025050d56a3e1cc833222e4f3b59e18",
+                            1.0
+                        ],
+                        [
+                            "7956317130124c32afd07b3f2432a3e92c1447cf58da95491a307ae3d564535e",
+                            2.0
+                        ]
+                    ]
+                }
+            }
+        ],
+        "receiving": [
+            {
+                "supports_labels": true,
+                "given": {
+                    "outpoints": [
+                        [
+                            "f4184fc596403b9d638783cf57adfe4c75c605f6356fbc91338530e9831e9e16",
+                            0
+                        ],
+                        [
+                            "a1075db55d416d3ca199f55b6084e2115b9345e16c5cf302fc80e9d5fbf5d48d",
+                            0
+                        ]
+                    ],
+                    "input_pub_keys": [
+                        "025a1e61f898173040e20616d43e9f496fba90338a39faa1ed98fcbaeee4dd9be5",
+                        "03782eeb913431ca6e9b8c2fd80a5f72ed2024ef72a3c6fb10263c379937323338"
+                    ],
+                    "bip32_seed": "f00dbabe",
+                    "scan_priv_key": "0f694e068028a717f8af6b9411f9a133dd3565258714cc226594b34db90c1f2c",
+                    "spend_priv_key": "9d6ad855ce3417ef84e836892e5a56392bfba05fa5d97ccea30e266f540e08b3",
+                    "labels": {
+                        "0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798": "0000000000000000000000000000000000000000000000000000000000000001"
+                    },
+                    "outputs": [
+                        "64f1c7e8992352d18cdbca600b9e1c3a6025050d56a3e1cc833222e4f3b59e18",
+                        "7956317130124c32afd07b3f2432a3e92c1447cf58da95491a307ae3d564535e"
+                    ]
+                },
+                "expected": {
+                    "addresses": [
+                        "sp1qqgste7k9hx0qftg6qmwlkqtwuy6cycyavzmzj85c6qdfhjdpdjtdgqjuexzk6murw56suy3e0rd2cgqvycxttddwsvgxe2usfpxumr70xc9pkqwv",
+                        "sp1qqgste7k9hx0qftg6qmwlkqtwuy6cycyavzmzj85c6qdfhjdpdjtdgqah4hxfsjdwyaeel4g8x2npkj7qlvf2692l5760z5ut0ggnlrhdzsy3cvsj"
+                    ],
+                    "outputs": [
+                        {
+                            "pub_key": "64f1c7e8992352d18cdbca600b9e1c3a6025050d56a3e1cc833222e4f3b59e18",
+                            "priv_key_tweak": "96439446f13ddaab2c5bc5a59a08992fd9d33bf8563c8a1b362730f4dc022e30",
+                            "signature": "3f6226feb9e4cafc0bdab8c9cfe085885308f3708c222bcec6cf26467685d897f51597abe39d1d279708e63513c7be23daed78607a98837060950493de188645"
+                        },
+                        {
+                            "pub_key": "7956317130124c32afd07b3f2432a3e92c1447cf58da95491a307ae3d564535e",
+                            "priv_key_tweak": "d39df91bd0e7825bfa1d30096febc5bf6fa7da79d7f25b7b4bea9538cc9a9f80",
+                            "signature": "567f0d4d914456141ca83fe89e99f008c1f7ab9e9a65d4a60162840824737407acbaa61d7efa1a6af5d6439d213187e2f76696bb657dc709a0077bbf3b40e2f2"
+                        }
+                    ]
+                }
+            }
+        ]
+    },
+    {
+        "comment": "Multiple outputs with labels: multiple outputs for labeled address; same recipient",
+        "sending": [
+            {
+                "given": {
+                    "outpoints": [
+                        [
+                            "f4184fc596403b9d638783cf57adfe4c75c605f6356fbc91338530e9831e9e16",
+                            0
+                        ],
+                        [
+                            "a1075db55d416d3ca199f55b6084e2115b9345e16c5cf302fc80e9d5fbf5d48d",
+                            0
+                        ]
+                    ],
+                    "input_priv_keys": [
+                        [
+                            "eadc78165ff1f8ea94ad7cfdc54990738a4c53f6e0507b42154201b8e5dff3b1",
+                            false
+                        ],
+                        [
+                            "0378e95685b74565fa56751b84a32dfd18545d10d691641b8372e32164fad66a",
+                            false
+                        ]
+                    ],
+                    "recipients": [
+                        [
+                            "sp1qqgste7k9hx0qftg6qmwlkqtwuy6cycyavzmzj85c6qdfhjdpdjtdgqah4hxfsjdwyaeel4g8x2npkj7qlvf2692l5760z5ut0ggnlrhdzsy3cvsj",
+                            3.0
+                        ],
+                        [
+                            "sp1qqgste7k9hx0qftg6qmwlkqtwuy6cycyavzmzj85c6qdfhjdpdjtdgqah4hxfsjdwyaeel4g8x2npkj7qlvf2692l5760z5ut0ggnlrhdzsy3cvsj",
+                            4.0
+                        ]
+                    ]
+                },
+                "expected": {
+                    "outputs": [
+                        [
+                            "8890c19f005d6f6add5fef92d37ac6b161b7fdd5c1aef6eed1d32be3f216ac4c",
+                            3.0
+                        ],
+                        [
+                            "7956317130124c32afd07b3f2432a3e92c1447cf58da95491a307ae3d564535e",
+                            4.0
+                        ]
+                    ]
+                }
+            }
+        ],
+        "receiving": [
+            {
+                "supports_labels": true,
+                "given": {
+                    "outpoints": [
+                        [
+                            "f4184fc596403b9d638783cf57adfe4c75c605f6356fbc91338530e9831e9e16",
+                            0
+                        ],
+                        [
+                            "a1075db55d416d3ca199f55b6084e2115b9345e16c5cf302fc80e9d5fbf5d48d",
+                            0
+                        ]
+                    ],
+                    "input_pub_keys": [
+                        "025a1e61f898173040e20616d43e9f496fba90338a39faa1ed98fcbaeee4dd9be5",
+                        "03782eeb913431ca6e9b8c2fd80a5f72ed2024ef72a3c6fb10263c379937323338"
+                    ],
+                    "bip32_seed": "f00dbabe",
+                    "scan_priv_key": "0f694e068028a717f8af6b9411f9a133dd3565258714cc226594b34db90c1f2c",
+                    "spend_priv_key": "9d6ad855ce3417ef84e836892e5a56392bfba05fa5d97ccea30e266f540e08b3",
+                    "labels": {
+                        "0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798": "0000000000000000000000000000000000000000000000000000000000000001"
+                    },
+                    "outputs": [
+                        "8890c19f005d6f6add5fef92d37ac6b161b7fdd5c1aef6eed1d32be3f216ac4c",
+                        "7956317130124c32afd07b3f2432a3e92c1447cf58da95491a307ae3d564535e"
+                    ]
+                },
+                "expected": {
+                    "addresses": [
+                        "sp1qqgste7k9hx0qftg6qmwlkqtwuy6cycyavzmzj85c6qdfhjdpdjtdgqjuexzk6murw56suy3e0rd2cgqvycxttddwsvgxe2usfpxumr70xc9pkqwv",
+                        "sp1qqgste7k9hx0qftg6qmwlkqtwuy6cycyavzmzj85c6qdfhjdpdjtdgqah4hxfsjdwyaeel4g8x2npkj7qlvf2692l5760z5ut0ggnlrhdzsy3cvsj"
+                    ],
+                    "outputs": [
+                        {
+                            "pub_key": "8890c19f005d6f6add5fef92d37ac6b161b7fdd5c1aef6eed1d32be3f216ac4c",
+                            "priv_key_tweak": "96439446f13ddaab2c5bc5a59a08992fd9d33bf8563c8a1b362730f4dc022e31",
+                            "signature": "f0eb3b826553709356c351e1ced49a72900f261be18e64914c3c694af94595a4a80417ecbf5e86fde8b08e451fb42ec36b7a9d733eb42f92206f4f6c78da66bb"
+                        },
+                        {
+                            "pub_key": "7956317130124c32afd07b3f2432a3e92c1447cf58da95491a307ae3d564535e",
+                            "priv_key_tweak": "d39df91bd0e7825bfa1d30096febc5bf6fa7da79d7f25b7b4bea9538cc9a9f80",
+                            "signature": "567f0d4d914456141ca83fe89e99f008c1f7ab9e9a65d4a60162840824737407acbaa61d7efa1a6af5d6439d213187e2f76696bb657dc709a0077bbf3b40e2f2"
+                        }
+                    ]
+                }
+            }
+        ]
+    },
+    {
+        "comment": "Multiple outputs with labels: un-labeled, labeled, and multiple outputs for labeled address; multiple recipients",
+        "sending": [
+            {
+                "given": {
+                    "outpoints": [
+                        [
+                            "f4184fc596403b9d638783cf57adfe4c75c605f6356fbc91338530e9831e9e16",
+                            0
+                        ],
+                        [
+                            "a1075db55d416d3ca199f55b6084e2115b9345e16c5cf302fc80e9d5fbf5d48d",
+                            0
+                        ]
+                    ],
+                    "input_priv_keys": [
+                        [
+                            "eadc78165ff1f8ea94ad7cfdc54990738a4c53f6e0507b42154201b8e5dff3b1",
+                            false
+                        ],
+                        [
+                            "0378e95685b74565fa56751b84a32dfd18545d10d691641b8372e32164fad66a",
+                            false
+                        ]
+                    ],
+                    "recipients": [
+                        [
+                            "sp1qqgste7k9hx0qftg6qmwlkqtwuy6cycyavzmzj85c6qdfhjdpdjtdgqjuexzk6murw56suy3e0rd2cgqvycxttddwsvgxe2usfpxumr70xc9pkqwv",
+                            5.0
+                        ],
+                        [
+                            "sp1qqgste7k9hx0qftg6qmwlkqtwuy6cycyavzmzj85c6qdfhjdpdjtdgqah4hxfsjdwyaeel4g8x2npkj7qlvf2692l5760z5ut0ggnlrhdzsy3cvsj",
+                            6.0
+                        ],
+                        [
+                            "sp1qqgste7k9hx0qftg6qmwlkqtwuy6cycyavzmzj85c6qdfhjdpdjtdgq562yg7htxyg8eq60rl37uul37jy62apnf5ru62uef0eajpdfrnp5cmqndj",
+                            7.0
+                        ],
+                        [
+                            "sp1qqgste7k9hx0qftg6qmwlkqtwuy6cycyavzmzj85c6qdfhjdpdjtdgq562yg7htxyg8eq60rl37uul37jy62apnf5ru62uef0eajpdfrnp5cmqndj",
+                            8.0
+                        ]
+                    ]
+                },
+                "expected": {
+                    "outputs": [
+                        [
+                            "64f1c7e8992352d18cdbca600b9e1c3a6025050d56a3e1cc833222e4f3b59e18",
+                            5.0
+                        ],
+                        [
+                            "7956317130124c32afd07b3f2432a3e92c1447cf58da95491a307ae3d564535e",
+                            6.0
+                        ],
+                        [
+                            "1b90a42136fef9ff2ca192abffc7be4536dc83d4e61cf18ae078f7e92b297cce",
+                            7.0
+                        ],
+                        [
+                            "87a82600c08a255bc97d172e10816e322967eed6a77c9f37dd926492d7fdc106",
+                            8.0
+                        ]
+                    ]
+                }
+            }
+        ],
+        "receiving": [
+            {
+                "supports_labels": true,
+                "given": {
+                    "outpoints": [
+                        [
+                            "f4184fc596403b9d638783cf57adfe4c75c605f6356fbc91338530e9831e9e16",
+                            0
+                        ],
+                        [
+                            "a1075db55d416d3ca199f55b6084e2115b9345e16c5cf302fc80e9d5fbf5d48d",
+                            0
+                        ]
+                    ],
+                    "input_pub_keys": [
+                        "025a1e61f898173040e20616d43e9f496fba90338a39faa1ed98fcbaeee4dd9be5",
+                        "03782eeb913431ca6e9b8c2fd80a5f72ed2024ef72a3c6fb10263c379937323338"
+                    ],
+                    "bip32_seed": "f00dbabe",
+                    "scan_priv_key": "0f694e068028a717f8af6b9411f9a133dd3565258714cc226594b34db90c1f2c",
+                    "spend_priv_key": "9d6ad855ce3417ef84e836892e5a56392bfba05fa5d97ccea30e266f540e08b3",
+                    "labels": {
+                        "0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798": "0000000000000000000000000000000000000000000000000000000000000001",
+                        "02db0c51cc634a4096374b0b895584a3ca2fb3bea4fd0ee2361f8db63a650fcee6": "0000000000000000000000000000000000000000000000000000000000000539"
+                    },
+                    "outputs": [
+                        "64f1c7e8992352d18cdbca600b9e1c3a6025050d56a3e1cc833222e4f3b59e18",
+                        "7956317130124c32afd07b3f2432a3e92c1447cf58da95491a307ae3d564535e",
+                        "1b90a42136fef9ff2ca192abffc7be4536dc83d4e61cf18ae078f7e92b297cce",
+                        "87a82600c08a255bc97d172e10816e322967eed6a77c9f37dd926492d7fdc106"
+                    ]
+                },
+                "expected": {
+                    "addresses": [
+                        "sp1qqgste7k9hx0qftg6qmwlkqtwuy6cycyavzmzj85c6qdfhjdpdjtdgqjuexzk6murw56suy3e0rd2cgqvycxttddwsvgxe2usfpxumr70xc9pkqwv",
+                        "sp1qqgste7k9hx0qftg6qmwlkqtwuy6cycyavzmzj85c6qdfhjdpdjtdgqah4hxfsjdwyaeel4g8x2npkj7qlvf2692l5760z5ut0ggnlrhdzsy3cvsj",
+                        "sp1qqgste7k9hx0qftg6qmwlkqtwuy6cycyavzmzj85c6qdfhjdpdjtdgq562yg7htxyg8eq60rl37uul37jy62apnf5ru62uef0eajpdfrnp5cmqndj"
+                    ],
+                    "outputs": [
+                        {
+                            "pub_key": "64f1c7e8992352d18cdbca600b9e1c3a6025050d56a3e1cc833222e4f3b59e18",
+                            "priv_key_tweak": "96439446f13ddaab2c5bc5a59a08992fd9d33bf8563c8a1b362730f4dc022e30",
+                            "signature": "3f6226feb9e4cafc0bdab8c9cfe085885308f3708c222bcec6cf26467685d897f51597abe39d1d279708e63513c7be23daed78607a98837060950493de188645"
+                        },
+                        {
+                            "pub_key": "7956317130124c32afd07b3f2432a3e92c1447cf58da95491a307ae3d564535e",
+                            "priv_key_tweak": "d39df91bd0e7825bfa1d30096febc5bf6fa7da79d7f25b7b4bea9538cc9a9f80",
+                            "signature": "567f0d4d914456141ca83fe89e99f008c1f7ab9e9a65d4a60162840824737407acbaa61d7efa1a6af5d6439d213187e2f76696bb657dc709a0077bbf3b40e2f2"
+                        },
+                        {
+                            "pub_key": "1b90a42136fef9ff2ca192abffc7be4536dc83d4e61cf18ae078f7e92b297cce",
+                            "priv_key_tweak": "255a912ad6cdebc0842d49fd9f7b2d81ee37d66c62839879371b699010f78ef1",
+                            "signature": "aa4cc7be2d90f30984d93535058f4894a6e0c7698deaaef179eda55724cc214e8e6ed055d437f1bf37c8c5c5431dad5080d03200cdd861a5b5e3855515e15d61"
+                        },
+                        {
+                            "pub_key": "87a82600c08a255bc97d172e10816e322967eed6a77c9f37dd926492d7fdc106",
+                            "priv_key_tweak": "d7535d792cb1388ab0b3bd5ff57337436d62f7719c1796beb5d80ab2fa34f307",
+                            "signature": "d68d0005118fcaae6d970925b452d038a03fda40d50aa9d6d3b4aff8189f226c71428838eadaf55662048f549bc7b19380438f09df9344eff30b96497b6aafa3"
+                        }
+                    ]
+                }
+            }
+        ]
+    },
+    {
+        "comment": "Single recipient: use silent payments for sender change",
+        "sending": [
+            {
+                "given": {
+                    "outpoints": [
+                        [
+                            "f4184fc596403b9d638783cf57adfe4c75c605f6356fbc91338530e9831e9e16",
+                            0
+                        ],
+                        [
+                            "a1075db55d416d3ca199f55b6084e2115b9345e16c5cf302fc80e9d5fbf5d48d",
+                            0
+                        ]
+                    ],
+                    "input_priv_keys": [
+                        [
+                            "eadc78165ff1f8ea94ad7cfdc54990738a4c53f6e0507b42154201b8e5dff3b1",
+                            false
+                        ],
+                        [
+                            "0378e95685b74565fa56751b84a32dfd18545d10d691641b8372e32164fad66a",
+                            false
+                        ]
+                    ],
+                    "recipients": [
+                        [
+                            "sp1qqgste7k9hx0qftg6qmwlkqtwuy6cycyavzmzj85c6qdfhjdpdjtdgqjuexzk6murw56suy3e0rd2cgqvycxttddwsvgxe2usfpxumr70xc9pkqwv",
+                            1.0
+                        ],
+                        [
+                            "sp1qqw6vczcfpdh5nf5y2ky99kmqae0tr30hgdfg88parz50cp80wd2wqqll5497pp2gcr4cmq0v5nv07x8u5jswmf8ap2q0kxmx8628mkqanyu63ck8",
+                            2.0
+                        ]
+                    ]
+                },
+                "expected": {
+                    "outputs": [
+                        [
+                            "64f1c7e8992352d18cdbca600b9e1c3a6025050d56a3e1cc833222e4f3b59e18",
+                            1.0
+                        ],
+                        [
+                            "0050c52a32566c0dfb517e473c68fedce4bd4543d219348d3bbdceeeb5755e34",
+                            2.0
+                        ]
+                    ]
+                }
+            }
+        ],
+        "receiving": [
+            {
+                "supports_labels": true,
+                "given": {
+                    "outpoints": [
+                        [
+                            "f4184fc596403b9d638783cf57adfe4c75c605f6356fbc91338530e9831e9e16",
+                            0
+                        ],
+                        [
+                            "a1075db55d416d3ca199f55b6084e2115b9345e16c5cf302fc80e9d5fbf5d48d",
+                            0
+                        ]
+                    ],
+                    "input_pub_keys": [
+                        "025a1e61f898173040e20616d43e9f496fba90338a39faa1ed98fcbaeee4dd9be5",
+                        "03782eeb913431ca6e9b8c2fd80a5f72ed2024ef72a3c6fb10263c379937323338"
+                    ],
+                    "bip32_seed": "deadbeef",
+                    "scan_priv_key": "11b7a82e06ca2648d5fded2366478078ec4fc9dc1d8ff487518226f229d768fd",
+                    "spend_priv_key": "b8f87388cbb41934c50daca018901b00070a5ff6cc25a7e9e716a9d5b9e4d664",
+                    "labels": {
+                        "02295dc38e877b754c0d0ed767434f1572cf34a82ccc06ffea1d9e04f1f7878e1a": "91cb04398a508c9d995ff4a18e5eae24d5e9488309f189120a3fdbb977978c46"
+                    },
+                    "outputs": [
+                        "64f1c7e8992352d18cdbca600b9e1c3a6025050d56a3e1cc833222e4f3b59e18",
+                        "0050c52a32566c0dfb517e473c68fedce4bd4543d219348d3bbdceeeb5755e34"
+                    ]
+                },
+                "expected": {
+                    "addresses": [
+                        "sp1qqw6vczcfpdh5nf5y2ky99kmqae0tr30hgdfg88parz50cp80wd2wqqauj52ymtc4xdkmx3tgyhrsemg2g3303xk2gtzfy8h8ejet8fz8jcw23zua",
+                        "sp1qqw6vczcfpdh5nf5y2ky99kmqae0tr30hgdfg88parz50cp80wd2wqqll5497pp2gcr4cmq0v5nv07x8u5jswmf8ap2q0kxmx8628mkqanyu63ck8"
+                    ],
+                    "outputs": [
+                        {
+                            "pub_key": "0050c52a32566c0dfb517e473c68fedce4bd4543d219348d3bbdceeeb5755e34",
+                            "priv_key_tweak": "2e9c2a37cfa7827907d36357f0632d258dbd14b3a7854937ecf732fb6acefdc8",
+                            "signature": "6ba068ee36454c5ff002082578e234917de9e384df739c43a8b7c4cce58724cba4479191cf972b235bc4bb6c2a8d6081650d1d5ba043b59bd51d6ac15d55b396"
+                        }
+                    ]
+                }
+            },
+            {
+                "supports_labels": false,
+                "given": {
+                    "outpoints": [
+                        [
+                            "f4184fc596403b9d638783cf57adfe4c75c605f6356fbc91338530e9831e9e16",
+                            0
+                        ],
+                        [
+                            "a1075db55d416d3ca199f55b6084e2115b9345e16c5cf302fc80e9d5fbf5d48d",
+                            0
+                        ]
+                    ],
+                    "input_pub_keys": [
+                        "025a1e61f898173040e20616d43e9f496fba90338a39faa1ed98fcbaeee4dd9be5",
+                        "03782eeb913431ca6e9b8c2fd80a5f72ed2024ef72a3c6fb10263c379937323338"
+                    ],
+                    "bip32_seed": "f00dbabe",
+                    "scan_priv_key": "0f694e068028a717f8af6b9411f9a133dd3565258714cc226594b34db90c1f2c",
+                    "spend_priv_key": "9d6ad855ce3417ef84e836892e5a56392bfba05fa5d97ccea30e266f540e08b3",
+                    "labels": {},
+                    "outputs": [
+                        "64f1c7e8992352d18cdbca600b9e1c3a6025050d56a3e1cc833222e4f3b59e18",
+                        "0050c52a32566c0dfb517e473c68fedce4bd4543d219348d3bbdceeeb5755e34"
+                    ]
+                },
+                "expected": {
+                    "addresses": [
+                        "sp1qqgste7k9hx0qftg6qmwlkqtwuy6cycyavzmzj85c6qdfhjdpdjtdgqjuexzk6murw56suy3e0rd2cgqvycxttddwsvgxe2usfpxumr70xc9pkqwv"
+                    ],
+                    "outputs": [
+                        {
+                            "pub_key": "64f1c7e8992352d18cdbca600b9e1c3a6025050d56a3e1cc833222e4f3b59e18",
+                            "priv_key_tweak": "96439446f13ddaab2c5bc5a59a08992fd9d33bf8563c8a1b362730f4dc022e30",
+                            "signature": "3f6226feb9e4cafc0bdab8c9cfe085885308f3708c222bcec6cf26467685d897f51597abe39d1d279708e63513c7be23daed78607a98837060950493de188645"
+                        }
+                    ]
+                }
+            }
+        ]
+    }
+]
diff --git a/test/integration/addresses_test.dart b/test/integration/addresses_test.dart
index 3f53bc6..e122db7 100644
--- a/test/integration/addresses_test.dart
+++ b/test/integration/addresses_test.dart
@@ -1,20 +1,15 @@
 import 'dart:typed_data';
 
-import '../../lib/src/models/networks.dart' as NETWORKS;
+import 'package:bitcoin_flutter/src/models/networks.dart' as NETWORKS;
+import 'package:bitcoin_flutter/src/payments/address/address.dart';
+import 'package:bitcoin_flutter/src/utils/uint8list.dart';
 import '../../lib/src/ecpair.dart' show ECPair;
 import '../../lib/src/payments/index.dart' show PaymentData;
-import '../../lib/src/payments/p2pkh.dart' show P2PKH, P2PKHData;
 import '../../lib/src/payments/p2wpkh.dart' show P2WPKH;
 import 'package:pointycastle/digests/sha256.dart';
 import 'dart:convert';
 import 'package:test/test.dart';
 
-NETWORKS.NetworkType litecoin = new NETWORKS.NetworkType(
-    messagePrefix: '\x19Litecoin Signed Message:\n',
-    bip32: new NETWORKS.Bip32Type(public: 0x019da462, private: 0x019d9cfe),
-    pubKeyHash: 0x30,
-    scriptHash: 0x32,
-    wif: 0xb0);
 // deterministic RNG for testing only
 rng(int number) {
   return utf8.encode('zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz');
@@ -24,70 +19,47 @@ main() {
   group('bitcoinjs-lib (addresses)', () {
     test('can generate a random address', () {
       final keyPair = ECPair.makeRandom(rng: rng);
-      final address =
-          new P2PKH(data: new PaymentData(pubkey: keyPair.publicKey))
-              .data
-              .address;
+      final address = new P2pkhAddress(pubkey: keyPair.publicKey.hex).address;
       expect(address, '1F5VhMHukdnUES9kfXqzPzMeF1GPHKiF64');
     });
     test('can generate an address from a SHA256 hash', () {
       final hash = new SHA256Digest()
           .process(Uint8List.fromList(utf8.encode('correct horse battery staple')));
       final keyPair = ECPair.fromPrivateKey(hash);
-      final address =
-          new P2PKH(data: new PaymentData(pubkey: keyPair.publicKey))
-              .data
-              .address;
+      final address = new P2pkhAddress(pubkey: keyPair.publicKey.hex).address;
       expect(address, '1C7zdTfnkzmr13HfA2vNm5SJYRK6nEKyq8');
     });
     test('can import an address via WIF', () {
-      final keyPair = ECPair.fromWIF(
-          'Kxr9tQED9H44gCmp6HAdmemAzU3n84H3dGkuWTKvE23JgHMW8gct');
-      final address =
-          new P2PKH(data: new PaymentData(pubkey: keyPair.publicKey))
-              .data
-              .address;
+      final keyPair = ECPair.fromWIF('Kxr9tQED9H44gCmp6HAdmemAzU3n84H3dGkuWTKvE23JgHMW8gct');
+      final address = new P2pkhAddress(pubkey: keyPair.publicKey.hex).address;
       expect(address, '19AAjaTUbRjQCMuVczepkoPswiZRhjtg31');
     });
     test('can generate a Testnet address', () {
       final testnet = NETWORKS.testnet;
       final keyPair = ECPair.makeRandom(network: testnet, rng: rng);
       final wif = keyPair.toWIF();
-      final address = new P2PKH(
-              data: new PaymentData(pubkey: keyPair.publicKey),
-              network: testnet)
-          .data
-          .address;
+      final address = new P2pkhAddress(pubkey: keyPair.publicKey.hex, networkType: testnet).address;
       expect(address, 'mubSzQNtZfDj1YdNP6pNDuZy6zs6GDn61L');
       expect(wif, 'cRgnQe9MUu1JznntrLaoQpB476M8PURvXVQB5R2eqms5tXnzNsrr');
     });
     test('can generate a Litecoin address', () {
+      final litecoin = NETWORKS.litecoin;
       final keyPair = ECPair.makeRandom(network: litecoin, rng: rng);
       final wif = keyPair.toWIF();
-      final address = new P2PKH(
-              data: new PaymentData(pubkey: keyPair.publicKey),
-              network: litecoin)
-          .data
-          .address;
+      final address =
+          new P2pkhAddress(pubkey: keyPair.publicKey.hex, networkType: litecoin).address;
       expect(address, 'LZJSxZbjqJ2XVEquqfqHg1RQTDdfST5PTn');
       expect(wif, 'T7A4PUSgTDHecBxW1ZiYFrDNRih2o7M8Gf9xpoCgudPF9gDiNvuS');
     });
     test('can generate a SegWit address', () {
-      final keyPair = ECPair.fromWIF(
-          'KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYjgd9M7rFU73sVHnoWn');
-      final address =
-          new P2WPKH(data: new PaymentData(pubkey: keyPair.publicKey))
-              .data
-              .address;
+      final keyPair = ECPair.fromWIF('KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYjgd9M7rFU73sVHnoWn');
+      final address = new P2WPKH(data: new PaymentData(pubkey: keyPair.publicKey)).data.address;
       expect(address, 'bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t4');
     });
     test('can generate a SegWit testnet address', () {
       final testnet = NETWORKS.testnet;
-      final keyPair = ECPair.fromWIF(
-          'cPaJYBMDLjQp5gSUHnBfhX4Rgj95ekBS6oBttwQLw3qfsKKcDfuB');
-      final address = new P2WPKH(
-              data: new PaymentData(pubkey: keyPair.publicKey),
-              network: testnet)
+      final keyPair = ECPair.fromWIF('cPaJYBMDLjQp5gSUHnBfhX4Rgj95ekBS6oBttwQLw3qfsKKcDfuB');
+      final address = new P2WPKH(data: new PaymentData(pubkey: keyPair.publicKey), network: testnet)
           .data
           .address;
       expect(address, 'tb1qgmp0h7lvexdxx9y05pmdukx09xcteu9sx2h4ya');
diff --git a/test/integration/bip32_test.dart b/test/integration/bip32_test.dart
index 37c6dae..620f1b1 100644
--- a/test/integration/bip32_test.dart
+++ b/test/integration/bip32_test.dart
@@ -1,8 +1,8 @@
 import 'dart:typed_data';
 
 import 'package:bitcoin_flutter/src/models/networks.dart';
-import 'package:bitcoin_flutter/src/payments/index.dart' show PaymentData;
-import 'package:bitcoin_flutter/src/payments/p2pkh.dart';
+import 'package:bitcoin_flutter/src/payments/address/address.dart';
+import 'package:bitcoin_flutter/src/utils/uint8list.dart';
 import 'package:test/test.dart';
 import 'package:hex/hex.dart';
 import 'package:bip39/bip39.dart' as bip39;
@@ -18,10 +18,8 @@ void main() {
           bip32.NetworkType(
               wif: testnet.wif,
               bip32: new bip32.Bip32Type(
-                  public: testnet.bip32.public,
-                  private: testnet.bip32.private)));
-      expect(
-          node.toWIF(), 'cQfoY67cetFNunmBUX5wJiw3VNoYx3gG9U9CAofKE6BfiV1fSRw7');
+                  public: testnet.bip32.public, private: testnet.bip32.private)));
+      expect(node.toWIF(), 'cQfoY67cetFNunmBUX5wJiw3VNoYx3gG9U9CAofKE6BfiV1fSRw7');
     });
     test('can export a BIP32 xpriv, then import it', () {
       const mnemonic =
@@ -44,8 +42,8 @@ void main() {
     });
     test('can create a BIP32, bitcoin, account 0, external address', () {
       const path = "m/0'/0/0";
-      final root = bip32.BIP32.fromSeed(Uint8List.fromList(HEX.decode(
-          'dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd')));
+      final root = bip32.BIP32.fromSeed(Uint8List.fromList(
+          HEX.decode('dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd')));
       final child1 = root.derivePath(path);
       // option 2, manually
       final child1b = root.deriveHardened(0).derive(0).derive(0);
@@ -53,16 +51,12 @@ void main() {
       expect(getAddress(child1b), '1JHyB1oPXufr4FXkfitsjgNB5yRY9jAaa7');
     });
     test('can create a BIP44, bitcoin, account 0, external address', () {
-      final root = bip32.BIP32.fromSeed(Uint8List.fromList(HEX.decode(
-          'dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd')));
+      final root = bip32.BIP32.fromSeed(Uint8List.fromList(
+          HEX.decode('dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd')));
       final child1 = root.derivePath("m/44'/0'/0'/0/0");
       // option 2, manually
-      final child1b = root
-          .deriveHardened(44)
-          .deriveHardened(0)
-          .deriveHardened(0)
-          .derive(0)
-          .derive(0);
+      final child1b =
+          root.deriveHardened(44).deriveHardened(0).deriveHardened(0).derive(0).derive(0);
       expect(getAddress(child1), '12Tyvr1U8A3ped6zwMEU5M8cx3G38sP5Au');
       expect(getAddress(child1b), '12Tyvr1U8A3ped6zwMEU5M8cx3G38sP5Au');
     });
@@ -76,21 +70,15 @@ void main() {
       final seed = bip39.mnemonicToSeed(mnemonic);
       final root = bip32.BIP32.fromSeed(seed);
       // receive addresses
-      expect(getAddress(root.derivePath("m/0'/0/0")),
-          '1AVQHbGuES57wD68AJi7Gcobc3RZrfYWTC');
-      expect(getAddress(root.derivePath("m/0'/0/1")),
-          '1Ad6nsmqDzbQo5a822C9bkvAfrYv9mc1JL');
+      expect(getAddress(root.derivePath("m/0'/0/0")), '1AVQHbGuES57wD68AJi7Gcobc3RZrfYWTC');
+      expect(getAddress(root.derivePath("m/0'/0/1")), '1Ad6nsmqDzbQo5a822C9bkvAfrYv9mc1JL');
       // change addresses
-      expect(getAddress(root.derivePath("m/0'/1/0")),
-          '1349KVc5NgedaK7DvuD4xDFxL86QN1Hvdn');
-      expect(getAddress(root.derivePath("m/0'/1/1")),
-          '1EAvj4edpsWcSer3duybAd4KiR4bCJW5J6');
+      expect(getAddress(root.derivePath("m/0'/1/0")), '1349KVc5NgedaK7DvuD4xDFxL86QN1Hvdn');
+      expect(getAddress(root.derivePath("m/0'/1/1")), '1EAvj4edpsWcSer3duybAd4KiR4bCJW5J6');
     });
   });
 }
 
-String? getAddress(node, [network]) {
-  return P2PKH(data: new PaymentData(pubkey: node.publicKey), network: network)
-      .data
-      .address;
+String? getAddress(bip32.BIP32 node, [NetworkType? network]) {
+  return P2pkhAddress(pubkey: node.publicKey.hex, networkType: network).address;
 }
diff --git a/test/integration/transactions_test.dart b/test/integration/transactions_test.dart
index 574b0f8..0d31a51 100644
--- a/test/integration/transactions_test.dart
+++ b/test/integration/transactions_test.dart
@@ -1,7 +1,7 @@
 import 'package:test/test.dart';
 import '../../lib/src/ecpair.dart';
 import '../../lib/src/transaction_builder.dart';
-import '../../lib/src/models/networks.dart' as NETWORKS;
+import 'package:bitcoin_flutter/src/models/networks.dart' as NETWORKS;
 import '../../lib/src/payments/p2wpkh.dart' show P2WPKH;
 import '../../lib/src/payments/index.dart' show PaymentData;
 
diff --git a/test/payments/p2pkh_test.dart b/test/payments/p2pkh_test.dart
index b8f09c6..7c84e5b 100644
--- a/test/payments/p2pkh_test.dart
+++ b/test/payments/p2pkh_test.dart
@@ -1,74 +1,90 @@
 import 'package:bitcoin_flutter/src/payments/index.dart' show PaymentData;
-import 'package:bitcoin_flutter/src/payments/p2pkh.dart';
+import 'package:bitcoin_flutter/src/payments/address/address.dart';
+import 'package:bitcoin_flutter/src/payments/script/script.dart';
 import 'package:test/test.dart';
 import 'package:bitcoin_flutter/src/utils/script.dart' as bscript;
+import 'package:bitcoin_flutter/src/utils/uint8list.dart';
+import 'package:bitcoin_flutter/src/utils/string.dart';
 import 'dart:io';
 import 'dart:convert';
-import 'package:hex/hex.dart';
-import 'dart:typed_data';
 
 main() {
-  final fixtures = json.decode(new File("./test/fixtures/p2pkh.json").readAsStringSync(encoding: utf8));
+  final fixtures =
+      json.decode(new File("./test/fixtures/p2pkh.json").readAsStringSync(encoding: utf8));
   group('(valid case)', () {
     (fixtures["valid"] as List<dynamic>).forEach((f) {
       test(f['description'] + ' as expected', () {
         final arguments = _preformPaymentData(f['arguments']);
-        final p2pkh = new P2PKH(data: arguments);
+        final p2pkh = new P2pkhAddress(
+          address: arguments.address,
+          hash160: arguments.hash?.hex,
+          pubkey: arguments.pubkey?.hex,
+          signature: arguments.signature?.hex,
+          scriptSig: arguments.input != null ? Script.fromRaw(byteData: arguments.input) : null,
+          scriptPubKey:
+              arguments.output != null ? Script.fromRaw(byteData: arguments.output) : null,
+        );
+
         if (arguments.address == null) {
-          expect(p2pkh.data.address, f['expected']['address']);
+          expect(p2pkh.address, f['expected']['address']);
         }
         if (arguments.hash == null) {
-          expect(_toString(p2pkh.data.hash), f['expected']['hash']);
+          expect(p2pkh.h160, f['expected']['hash']);
         }
         if (arguments.pubkey == null) {
-          expect(_toString(p2pkh.data.pubkey), f['expected']['pubkey']);
+          expect(p2pkh.pubkey, f['expected']['pubkey']);
         }
-        if (arguments.input == null) {
-          expect(_toString(p2pkh.data.input), f['expected']['input']);
+        if (arguments.input == null && f['expected']['input'] != null) {
+          expect(
+              Script(script: [p2pkh.signature, p2pkh.pubkey]).toString(), f['expected']['input']);
         }
         if (arguments.output == null) {
-          expect(_toString(p2pkh.data.output), f['expected']['output']);
+          expect(p2pkh.scriptPubkey.toString(), f['expected']['output']);
         }
         if (arguments.signature == null) {
-          expect(_toString(p2pkh.data.signature), f['expected']['signature']);
+          expect(p2pkh.signature, f['expected']['signature']);
         }
       });
     });
   });
   group('(invalid case)', () {
     (fixtures["invalid"] as List<dynamic>).forEach((f) {
-      test('throws ' + f['exception'] + (f['description'] != null ? ('for ' + f['description']) : ''), () {
+      test(
+          'throws ' +
+              f['exception'] +
+              (f['description'] != null ? (' for ' + f['description']) : ''), () {
         final arguments = _preformPaymentData(f['arguments']);
         try {
-          expect(new P2PKH(data: arguments), isArgumentError);
-        } catch(err) {
+          expect(
+              new P2pkhAddress(
+                address: arguments.address,
+                hash160: arguments.hash?.hex,
+                pubkey: arguments.pubkey?.hex,
+                signature: arguments.signature?.hex,
+                scriptSig:
+                    arguments.input != null ? Script.fromRaw(byteData: arguments.input) : null,
+                scriptPubKey:
+                    arguments.output != null ? Script.fromRaw(byteData: arguments.output) : null,
+              ),
+              isArgumentError);
+        } catch (err) {
           expect((err as ArgumentError).message, f['exception']);
         }
-
       });
     });
   });
 }
 
 PaymentData _preformPaymentData(dynamic x) {
-  final address = x['address'];
-  final hash = x['hash'] != null ? Uint8List.fromList(HEX.decode(x['hash'])) : null;
-  final input = x['input'] != null ? bscript.fromASM(x['input']) : null;
-  final output = x['output'] != null ? bscript.fromASM(x['output']) : x['outputHex'] != null ? Uint8List.fromList(HEX.decode(x['outputHex'])) : null;
-  final pubkey = x['pubkey'] != null ? Uint8List.fromList(HEX.decode(x['pubkey'])) : null;
-  final signature = x['signature'] != null ? Uint8List.fromList(HEX.decode(x['signature'])) : null;
-  return new PaymentData(address: address, hash: hash, input: input, output: output, pubkey: pubkey, signature: signature);
-}
-
-String? _toString(dynamic x) {
-  if (x == null) {
-    return null;
-  }
-  if (x is Uint8List) {
-    return HEX.encode(x);
-  }
-  if (x is List<dynamic>) {
-    return bscript.toASM(x);
-  }
-  return '';
+  return new PaymentData(
+      address: x['address'],
+      hash: x['hash'] != null ? (x['hash'] as String).fromHex : null,
+      input: x['input'] != null ? bscript.fromASM(x['input']) : null,
+      output: x['output'] != null
+          ? bscript.fromASM(x['output'])
+          : x['outputHex'] != null
+              ? (x['outputHex'] as String).fromHex
+              : null,
+      pubkey: x['pubkey'] != null ? (x['pubkey'] as String).fromHex : null,
+      signature: x['signature'] != null ? (x['signature'] as String).fromHex : null);
 }
diff --git a/test/silentpayments.dart b/test/silentpayments.dart
new file mode 100644
index 0000000..bf6183b
--- /dev/null
+++ b/test/silentpayments.dart
@@ -0,0 +1,172 @@
+import 'dart:convert';
+import 'dart:io';
+import 'dart:typed_data';
+
+import 'package:bitcoin_flutter/src/utils/bigint.dart';
+import 'package:elliptic/elliptic.dart';
+import 'package:bitcoin_flutter/src/payments/scanning.dart';
+import 'package:bitcoin_flutter/src/payments/silentpayments.dart';
+import 'package:bitcoin_flutter/src/utils/string.dart';
+import 'package:bitcoin_flutter/src/utils/uint8list.dart';
+import 'package:bitcoin_flutter/src/utils/keys.dart';
+import 'package:bitcoin_flutter/src/templates/silentpaymentaddress.dart';
+import 'package:bitcoin_flutter/src/templates/outpoint.dart';
+import 'package:bitcoin_flutter/src/ec/schnorr.dart';
+import 'package:hex/hex.dart';
+import 'package:pointycastle/digests/sha256.dart';
+import 'package:test/test.dart';
+
+main() {
+  final curve = getSecp256k1();
+
+  final fixtures =
+      json.decode(new File('test/fixtures/silent_payments.json').readAsStringSync(encoding: utf8));
+
+  for (var testCase in fixtures) {
+    test(testCase['comment'], () {
+      Map<String, List<(PublicKey, int)>> sendingOutputs = {};
+      List<String> sendingOutputPubKeys = [];
+
+      // Test sending
+      for (var sendingTest in testCase['sending']) {
+        var given = sendingTest["given"];
+
+        List<PrivateKeyInfo> inputPrivKeys = [];
+        for (List<dynamic> inputPrivKeyInfo in given['input_priv_keys']) {
+          inputPrivKeys.add(
+              PrivateKeyInfo(PrivateKey.fromHex(curve, inputPrivKeyInfo[0]), inputPrivKeyInfo[1]));
+        }
+
+        List<Outpoint> outpoints = [];
+        for (List<dynamic> outpoint in given['outpoints']) {
+          outpoints.add(Outpoint(txid: outpoint[0], index: outpoint[1]));
+        }
+
+        List<SilentPaymentDestination> silentPaymentDestinations = [];
+        for (List<dynamic> recipientInfo in given['recipients']) {
+          silentPaymentDestinations.add(
+              SilentPaymentDestination.fromAddress(recipientInfo[0], recipientInfo[1].floor()));
+        }
+
+        sendingOutputs = SilentPayment.generateMultipleRecipientPubkeys(
+            inputPrivKeys, SilentPayment.hashOutpoints(outpoints), silentPaymentDestinations);
+
+        var expectedDestinations = sendingTest['expected']['outputs'];
+
+        var i = 0;
+        sendingOutputs.forEach((silentAddress, generatedOutputs) {
+          final expectedSilentAddress = silentPaymentDestinations[i].toString();
+          expect(silentAddress, expectedSilentAddress);
+
+          generatedOutputs.forEach((output) {
+            final expectedPubkey = expectedDestinations[i][0];
+            final generatedPubkey = output.$1.toCompressedHex(); // TODO: program
+
+            expect(generatedPubkey.fromHex.sublist(1).hex, expectedPubkey);
+
+            sendingOutputPubKeys.add(generatedPubkey);
+
+            final expectedAmount = expectedDestinations[i][1].floor();
+            final returnedAmount = output.$2;
+            expect(returnedAmount, expectedAmount);
+
+            i++;
+          });
+        });
+      }
+
+      final msg = SHA256Digest().process(Uint8List.fromList(utf8.encode('message')));
+      final aux = SHA256Digest().process(Uint8List.fromList(utf8.encode('random auxiliary data')));
+
+      // Test receiving
+      for (var receivingTest in testCase['receiving']) {
+        var given = receivingTest["given"];
+
+        List<dynamic> outputsToCheck = given['outputs'];
+
+        // assert that the generated sending outputs are a subset
+        // of the expected receiving outputs
+        // i.e. all the generated outputs are present
+        expect(
+            sendingOutputPubKeys
+                .every((element) => given['outputs'].contains(element.fromHex.sublist(1).hex)),
+            true);
+
+        var receivingAddresses = [];
+
+        var silentPaymentReceiver = SilentPaymentReceiver.fromPrivKeys(
+            scanPrivkey: PrivateKey.fromHex(curve, given["scan_priv_key"]),
+            spendPrivkey: PrivateKey.fromHex(curve, given["spend_priv_key"]));
+
+        // Add change address
+        receivingAddresses.add(silentPaymentReceiver);
+
+        Map<String, String>? labels = null;
+        for (var label in given['labels'].entries) {
+          final m = label.value;
+          receivingAddresses.add(SilentPaymentAddress.createLabeledSilentPaymentAddress(
+              silentPaymentReceiver.scanPubkey,
+              silentPaymentReceiver.spendPubkey,
+              Uint8List.fromList(HEX.decode(m))));
+
+          if (labels == null) {
+            labels = {};
+          }
+          labels[label.key] = m;
+        }
+
+        List<Outpoint> outpoints = [];
+        for (var outpoint in given['outpoints']) {
+          outpoints.add(Outpoint(txid: outpoint[0], index: outpoint[1]));
+        }
+
+        final outpointsHash = SilentPayment.hashOutpoints(outpoints);
+
+        List<String> inputPubKeys = [];
+        for (var inputPubKey in given['input_pub_keys']) {
+          inputPubKeys.add(inputPubKey);
+        }
+
+        final addToWallet = scanOutputs(
+            silentPaymentReceiver.scanPrivkey,
+            silentPaymentReceiver.spendPubkey,
+            getSumInputPubKeys(inputPubKeys),
+            outpointsHash,
+            outputsToCheck.map((e) => Uint8List.fromList(HEX.decode(e))).toList(),
+            labels: labels);
+
+        var expectedDestinations = receivingTest['expected']['outputs'];
+
+        // Check that the private key is correct for the found output public key
+        for (int i = 0; i < expectedDestinations.length; i++) {
+          final output = addToWallet.entries.elementAt(i);
+          final pubkey = output.key;
+          final expectedPubkey = expectedDestinations[i]["pub_key"];
+          expect(pubkey, expectedPubkey);
+
+          final privKeyTweak = output.value[0];
+          final expectedPrivKeyTweak = expectedDestinations[i]["priv_key_tweak"];
+          expect(privKeyTweak, expectedPrivKeyTweak);
+
+          final fullPrivateKey = PrivateKey(curve, silentPaymentReceiver.spendPrivkey.D)
+              .tweakAdd(privKeyTweak.fromHex.bigint)!;
+
+          if (fullPrivateKey.toCompressedHex().fromHex[0] == 0x03) {
+            fullPrivateKey.negate();
+          }
+
+          // Sign the message with schnorr
+          final sig = schnorrSign(msg, fullPrivateKey.D.decode, aux);
+
+          // Verify the message is correct
+          expect(verifySchnorr(msg, pubkey.fromHex, sig), true);
+
+          // Verify the signature is correct
+          expect(sig.hex, expectedDestinations[i]["signature"]);
+
+          i++;
+        }
+      }
+    });
+  }
+}
diff --git a/test/transaction_builder_test.dart b/test/transaction_builder_test.dart
index 9a53874..8897281 100644
--- a/test/transaction_builder_test.dart
+++ b/test/transaction_builder_test.dart
@@ -3,14 +3,15 @@ import 'dart:io';
 import 'dart:convert';
 import 'dart:typed_data';
 import 'package:hex/hex.dart';
-import '../lib/src/models/networks.dart';
+import 'package:bitcoin_flutter/src/models/networks.dart';
+import 'package:bitcoin_flutter/src/payments/constants/constants.dart';
 import '../lib/src/ecpair.dart';
 import '../lib/src/transaction.dart';
 import '../lib/src/address.dart';
 import '../lib/src/transaction_builder.dart';
 import '../lib/src/utils/script.dart' as bscript;
-import '../lib/src/payments/index.dart' show PaymentData;
-import '../lib/src/payments/p2pkh.dart';
+import '../lib/src/utils/uint8list.dart';
+import '../lib/src/payments/address/address.dart';
 
 final NETWORKS = {'bitcoin': bitcoin, 'testnet': testnet};
 
@@ -21,11 +22,7 @@ constructSign(f, TransactionBuilder txb) {
     if (inputs[i]['signs'] == null) continue;
     (inputs[i]['signs'] as List<dynamic>).forEach((sign) {
       ECPair keyPair = ECPair.fromWIF(sign['keyPair'], network: network);
-      txb.sign(
-          vin: i,
-          keyPair: keyPair,
-          witnessValue: sign['value'],
-          hashType: sign['hashType']);
+      txb.sign(vin: i, keyPair: keyPair, witnessValue: sign['value'], hashType: sign['hashType']);
     });
   }
   return txb;
@@ -66,26 +63,21 @@ TransactionBuilder construct(f, [bool? dontSign]) {
 }
 
 main() {
-  final fixtures = json.decode(
-      new File('test/fixtures/transaction_builder.json')
-          .readAsStringSync(encoding: utf8));
+  final fixtures = json
+      .decode(new File('test/fixtures/transaction_builder.json').readAsStringSync(encoding: utf8));
   group('TransactionBuilder', () {
-    final keyPair = ECPair.fromPrivateKey(Uint8List.fromList(HEX.decode(
-        '0000000000000000000000000000000000000000000000000000000000000001')));
-    final scripts = [
-      '1BgGZ9tcN4rm9KBzDn7KprQz87SZ26SAMH',
-      '1cMh228HTCiwS8ZsaakH8A8wze1JR5ZsP'
-    ].map((x) => Address.addressToOutputScript(x));
-    final txHash = HEX.decode(
-        '0e7cea811c0be9f73c0aca591034396e7264473fc25c1ca45195d7417b36cbe2');
+    final keyPair = ECPair.fromPrivateKey(Uint8List.fromList(
+        HEX.decode('0000000000000000000000000000000000000000000000000000000000000001')));
+    final scripts = ['1BgGZ9tcN4rm9KBzDn7KprQz87SZ26SAMH', '1cMh228HTCiwS8ZsaakH8A8wze1JR5ZsP']
+        .map((x) => Address.addressToOutputScript(x));
+    final txHash = HEX.decode('0e7cea811c0be9f73c0aca591034396e7264473fc25c1ca45195d7417b36cbe2');
     group('fromTransaction', () {
       (fixtures['valid']['build'] as List<dynamic>).forEach((f) {
         test('returns TransactionBuilder, with ${f['description']}', () {
           final network = NETWORKS[f['network'] ?? 'bitcoin'];
           final tx = Transaction.fromHex(f['txHex']);
           final txb = TransactionBuilder.fromTransaction(tx, network);
-          final txAfter =
-              f['incomplete'] != null ? txb.buildIncomplete() : txb.build();
+          final txAfter = f['incomplete'] != null ? txb.buildIncomplete() : txb.build();
           expect(txAfter.toHex(), f['txHex']);
           expect(txb.network, network);
         });
@@ -95,10 +87,8 @@ main() {
           final tx = new Transaction();
           f['inputs'] as List<dynamic>
             ..forEach((input) {
-              final txHash2 = Uint8List.fromList(
-                  HEX.decode(input['txId']).reversed.toList());
-              tx.addInput(txHash2, input['vout'], null,
-                  bscript.fromASM(input['scriptSig']));
+              final txHash2 = Uint8List.fromList(HEX.decode(input['txId']).reversed.toList());
+              tx.addInput(txHash2, input['vout'], null, bscript.fromASM(input['scriptSig']));
             });
           f['outputs'] as List<dynamic>
             ..forEach((output) {
@@ -109,12 +99,10 @@ main() {
           final txAfter = f['incomplete'] ? txb.buildIncomplete() : txb.build();
 
           for (var i = 0; i < txAfter.ins.length; i++) {
-            test(bscript.toASM(txAfter.ins[i].script!),
-                f['inputs'][i]['scriptSigAfter']);
+            test(bscript.toASM(txAfter.ins[i].script!), f['inputs'][i]['scriptSigAfter']);
           }
           for (var i = 0; i < txAfter.outs.length; i++) {
-            test(bscript.toASM(txAfter.outs[i].script!),
-                f['outputs'][i]['script']);
+            test(bscript.toASM(txAfter.outs[i].script!), f['outputs'][i]['script']);
           }
         });
       });
@@ -171,17 +159,14 @@ main() {
         expect(txb.addInput(txHash, 0), 0);
         expect(txb.addInput(txHash, 1), 1);
       });
-      test(
-          'throws if SIGHASH_ALL has been used to sign any existing scriptSigs',
-          () {
+      test('throws if SIGHASH_ALL has been used to sign any existing scriptSigs', () {
         txb.addInput(txHash, 0);
         txb.addOutput(scripts.elementAt(0), 1000);
         txb.sign(vin: 0, keyPair: keyPair);
         try {
           expect(txb.addInput(txHash, 0), isArgumentError);
         } catch (err) {
-          expect((err as ArgumentError).message,
-              'No, this would invalidate signatures');
+          expect((err as ArgumentError).message, 'No, this would invalidate signatures');
         }
       });
     });
@@ -191,10 +176,7 @@ main() {
         txb = new TransactionBuilder();
       });
       test('accepts an address string and value', () {
-        final address =
-            new P2PKH(data: new PaymentData(pubkey: keyPair.publicKey))
-                .data
-                .address;
+        final address = new P2pkhAddress(pubkey: keyPair.publicKey.hex).address;
         final vout = txb.addOutput(address, 1000);
         expect(vout, 0);
         final txout = txb.tx.outs[0];
@@ -210,11 +192,9 @@ main() {
       });
       test('throws if address is of the wrong network', () {
         try {
-          expect(txb.addOutput('2NGHjvjw83pcVFgMcA7QvSMh2c246rxLVz9', 1000),
-              isArgumentError);
+          expect(txb.addOutput('2NGHjvjw83pcVFgMcA7QvSMh2c246rxLVz9', 1000), isArgumentError);
         } catch (err) {
-          expect((err as ArgumentError).message,
-              'Invalid version or Network mismatch');
+          expect((err as ArgumentError).message, 'Invalid version or Network mismatch');
         }
       });
       test('add second output after signed first input with SIGHASH_NONE', () {
@@ -228,8 +208,7 @@ main() {
         txb.sign(vin: 0, keyPair: keyPair, hashType: SIGHASH_NONE);
         expect(txb.addOutput(scripts.elementAt(0), 2000), 0);
       });
-      test('add second output after signed first input with SIGHASH_SINGLE',
-          () {
+      test('add second output after signed first input with SIGHASH_SINGLE', () {
         txb.addInput(txHash, 0);
         txb.addOutput(scripts.elementAt(0), 2000);
         txb.sign(vin: 0, keyPair: keyPair, hashType: SIGHASH_SINGLE);
@@ -241,21 +220,17 @@ main() {
         try {
           expect(txb.addOutput(scripts.elementAt(0), 2000), isArgumentError);
         } catch (err) {
-          expect((err as ArgumentError).message,
-              'No, this would invalidate signatures');
+          expect((err as ArgumentError).message, 'No, this would invalidate signatures');
         }
       });
-      test(
-          'throws if SIGHASH_ALL has been used to sign any existing scriptSigs',
-          () {
+      test('throws if SIGHASH_ALL has been used to sign any existing scriptSigs', () {
         txb.addInput(txHash, 0);
         txb.addOutput(scripts.elementAt(0), 2000);
         txb.sign(vin: 0, keyPair: keyPair);
         try {
           expect(txb.addOutput(scripts.elementAt(1), 9000), isArgumentError);
         } catch (err) {
-          expect((err as ArgumentError).message,
-              'No, this would invalidate signatures');
+          expect((err as ArgumentError).message, 'No, this would invalidate signatures');
         }
       });
     });
@@ -277,11 +252,13 @@ main() {
       });
       test('throws if too much data is provided', () {
         try {
-          expect(txb.addOutputData('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'),
+          expect(
+              txb.addOutputData(
+                  'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'),
               isArgumentError);
         } catch (err) {
-          expect((err as ArgumentError).message,
-              'Too much data embedded, max OP_RETURN size is 100');
+          expect(
+              (err as ArgumentError).message, 'Too much data embedded, max OP_RETURN size is 100');
         }
       });
       test('add second output after signed first input with SIGHASH_NONE', () {
@@ -295,36 +272,31 @@ main() {
         txb.sign(vin: 0, keyPair: keyPair, hashType: SIGHASH_NONE);
         expect(txb.addOutputData(data), 0);
       });
-      test('add second output after signed first input with SIGHASH_SINGLE',
-              () {
-            txb.addInput(txHash, 0);
-            txb.addOutputData(data);
-            txb.sign(vin: 0, keyPair: keyPair, hashType: SIGHASH_SINGLE);
-            expect(txb.addOutputData(data2), 1);
-          });
+      test('add second output after signed first input with SIGHASH_SINGLE', () {
+        txb.addInput(txHash, 0);
+        txb.addOutputData(data);
+        txb.sign(vin: 0, keyPair: keyPair, hashType: SIGHASH_SINGLE);
+        expect(txb.addOutputData(data2), 1);
+      });
       test('add first output after signed first input with SIGHASH_SINGLE', () {
         txb.addInput(txHash, 0);
         txb.sign(vin: 0, keyPair: keyPair, hashType: SIGHASH_SINGLE);
         try {
           expect(txb.addOutputData(data), isArgumentError);
         } catch (err) {
-          expect((err as ArgumentError).message,
-              'No, this would invalidate signatures');
+          expect((err as ArgumentError).message, 'No, this would invalidate signatures');
+        }
+      });
+      test('throws if SIGHASH_ALL has been used to sign any existing scriptSigs', () {
+        txb.addInput(txHash, 0);
+        txb.addOutputData(data);
+        txb.sign(vin: 0, keyPair: keyPair);
+        try {
+          expect(txb.addOutputData(data2), isArgumentError);
+        } catch (err) {
+          expect((err as ArgumentError).message, 'No, this would invalidate signatures');
         }
       });
-      test(
-          'throws if SIGHASH_ALL has been used to sign any existing scriptSigs',
-              () {
-            txb.addInput(txHash, 0);
-            txb.addOutputData(data);
-            txb.sign(vin: 0, keyPair: keyPair);
-            try {
-              expect(txb.addOutputData(data2), isArgumentError);
-            } catch (err) {
-              expect((err as ArgumentError).message,
-                  'No, this would invalidate signatures');
-            }
-          });
     });
     group('setLockTime', () {
       test('throws if if there exist any scriptSigs', () {
@@ -335,42 +307,32 @@ main() {
         try {
           expect(txb.setLockTime(65535), isArgumentError);
         } catch (err) {
-          expect((err as ArgumentError).message,
-              'No, this would invalidate signatures');
+          expect((err as ArgumentError).message, 'No, this would invalidate signatures');
         }
       });
     });
     group('sign', () {
       fixtures['invalid']['sign'] as List<dynamic>
         ..forEach((f) {
-          test(
-              'throws ${f['exception']} ${f['description'] != null ? f['description'] : ''}',
-              () {
+          test('throws ${f['exception']} ${f['description'] != null ? f['description'] : ''}', () {
             final txb = construct(f, true);
             var threw = false;
             final inputs = f['inputs'] as List;
             for (var i = 0; i < inputs.length; i++) {
               inputs[i]['signs'] as List<dynamic>
                 ..forEach((sign) {
-                  final keyPairNetwork =
-                      NETWORKS[sign['network'] ?? f['network']];
-                  final keyPair2 =
-                      ECPair.fromWIF(sign['keyPair'], network: keyPairNetwork);
+                  final keyPairNetwork = NETWORKS[sign['network'] ?? f['network']];
+                  final keyPair2 = ECPair.fromWIF(sign['keyPair'], network: keyPairNetwork);
                   if (sign['throws'] != null && sign['throws']) {
                     try {
-                      expect(
-                          txb.sign(
-                              vin: i,
-                              keyPair: keyPair2,
-                              hashType: sign['hashType']),
+                      expect(txb.sign(vin: i, keyPair: keyPair2, hashType: sign['hashType']),
                           isArgumentError);
                     } catch (err) {
                       expect((err as ArgumentError).message, f['exception']);
                     }
                     threw = true;
                   } else {
-                    txb.sign(
-                        vin: i, keyPair: keyPair2, hashType: sign['hashType']);
+                    txb.sign(vin: i, keyPair: keyPair2, hashType: sign['hashType']);
                   }
                 });
             }
@@ -383,8 +345,7 @@ main() {
         ..forEach((f) {
           test('builds ${f['description']}', () {
             final txb = construct(f);
-            final tx =
-                f['incomplete'] != null ? txb.buildIncomplete() : txb.build();
+            final tx = f['incomplete'] != null ? txb.buildIncomplete() : txb.build();
 
             expect(tx.toHex(), f['txHex']);
           });
@@ -396,8 +357,7 @@ main() {
               try {
                 TransactionBuilder txb;
                 if (f['txHex'] != null) {
-                  txb = TransactionBuilder.fromTransaction(
-                      Transaction.fromHex(f['txHex']));
+                  txb = TransactionBuilder.fromTransaction(Transaction.fromHex(f['txHex']));
                 } else {
                   txb = construct(f);
                 }
@@ -412,8 +372,7 @@ main() {
                 try {
                   TransactionBuilder txb;
                   if (f['txHex'] != null) {
-                    txb = TransactionBuilder.fromTransaction(
-                        Transaction.fromHex(f['txHex']));
+                    txb = TransactionBuilder.fromTransaction(Transaction.fromHex(f['txHex']));
                   } else {
                     txb = construct(f);
                   }
@@ -426,8 +385,7 @@ main() {
               test('does not throw if buildIncomplete', () {
                 TransactionBuilder txb;
                 if (f['txHex'] != null) {
-                  txb = TransactionBuilder.fromTransaction(
-                      Transaction.fromHex(f['txHex']));
+                  txb = TransactionBuilder.fromTransaction(Transaction.fromHex(f['txHex']));
                 } else {
                   txb = construct(f);
                 }