Make DLCReady Writable

Author: MatthewLM

coinlib/lib/src/crypto/schnorr_adaptor_signature.dart

@@ -1,3 +1,5 @@
+import 'dart:typed_data';
+import 'package:coinlib/src/common/serial.dart';
 import 'ec_private_key.dart';
 import 'schnorr_signature.dart';
 import 'package:coinlib/src/secp256k1/secp256k1.dart';
@@ -6,7 +8,7 @@ import 'package:coinlib/src/secp256k1/secp256k1.dart';
 /// signature can be adapted (decrypted) using [adapt] with the discrete-log of
 /// the point (private key to a public key). The signature will be complete and
 /// valid if the correct adaptor was given.
-class SchnorrAdaptorSignature {
+class SchnorrAdaptorSignature with Writable {
 
   /// The signature that contains the adapted nonce but requires the adaptor
   /// scalar
@@ -15,6 +17,12 @@ class SchnorrAdaptorSignature {
   final bool parity;
 
   SchnorrAdaptorSignature(this.preSig, this.parity);
+  SchnorrAdaptorSignature.fromReader(BytesReader reader)
+    : preSig = SchnorrSignature(reader.readSlice(SchnorrSignature.length)),
+      parity = reader.readUInt8() == 1;
+
+  SchnorrAdaptorSignature.fromBytes(Uint8List bytes)
+    : this.fromReader(BytesReader(bytes));
 
   /// Adapts the adaptor signature with the discrete log to the adaptor point
   /// given as an [ECPrivateKey]. The resulting signature is not verified.
@@ -52,4 +60,10 @@ class SchnorrAdaptorSignature {
     }
   }
 
+  @override
+  void write(Writer writer) {
+    writer.writeSlice(preSig.data);
+    writer.writeUInt8(parity ? 1 : 0);
+  }
+
 }

coinlib/lib/src/dlc/builder.dart

@@ -314,7 +314,6 @@ class DLCStatefulBuilder {
     );
 
     return DLCReady(
-      terms: terms,
       refundTransaction: signedRefundTx,
       cets: {
         for (final cet in _cets)

coinlib/lib/src/dlc/ready.dart

@@ -1,28 +1,48 @@
+import 'dart:typed_data';
+import 'package:coinlib/src/common/serial.dart';
 import 'package:coinlib/src/crypto/ec_public_key.dart';
 import 'package:coinlib/src/crypto/schnorr_adaptor_signature.dart';
 import 'package:coinlib/src/tx/transaction.dart';
-import 'terms.dart';
 
-class CETReady {
+class CETReady with Writable {
 
   final Transaction tx;
   final SchnorrAdaptorSignature adaptorSig;
 
   CETReady(this.tx, this.adaptorSig);
+  CETReady.fromReader(BytesReader reader)
+    : tx = Transaction.fromReader(reader),
+      adaptorSig = SchnorrAdaptorSignature.fromReader(reader);
+  CETReady.fromBytes(Uint8List bytes) : this.fromReader(BytesReader(bytes));
+
+  @override
+  void write(Writer writer) {
+    tx.write(writer);
+    adaptorSig.write(writer);
+  }
 
 }
 
-class DLCReady {
+/// Carries data for a DLC with fully signed [cets] and a [refundTransaction].
+/// After this has been created, the DLC requires funding before it can be used.
+class DLCReady with Writable {
 
-  final DLCTerms terms;
   final Transaction refundTransaction;
-  // TODO: Make immutable
   final Map<ECPublicKey, CETReady> cets;
 
   DLCReady({
-    required this.terms,
     required this.refundTransaction,
-    required this.cets,
-  });
+    required Map<ECPublicKey, CETReady> cets,
+  }) : cets = Map.unmodifiable(cets);
+  DLCReady.fromReader(BytesReader reader)
+    : refundTransaction = Transaction.fromReader(reader),
+      cets = reader.readXPubKeyMap(() => CETReady.fromReader(reader));
+  DLCReady.fromBytes(Uint8List bytes) : this.fromReader(BytesReader(bytes));
+
+  @override
+  void write(Writer writer) {
+    refundTransaction.write(writer);
+    writer.writeOrderedXPubkeyMap(cets, (cet) => cet.write(writer));
+  }
 
 }

coinlib/test/crypto/schnorr_adaptor_signature_test.dart

@@ -33,6 +33,14 @@ void main() {
 
     });
 
+    test("can read/write", () {
+      final readSig = SchnorrAdaptorSignature.fromBytes(
+        goodAdaptorSig.toBytes(),
+      );
+      expect(bytesToHex(readSig.preSig.data), validSchnorrSig);
+      expect(readSig.parity, false);
+    });
+
   });
 
 }

coinlib/test/dlc/builder_test.dart

@@ -239,7 +239,6 @@ void main() {
             Network.mainnet.minFee,
           )!;
 
-          expect(dlc.terms.toBytes(), buildersFor2CETs.first.terms.toBytes());
           expect(dlc.cets, hasLength(2));
           expect(
             dlc.cets.values.map((cet) => cet.tx),
@@ -264,7 +263,7 @@ void main() {
           expect(
             dlc.refundTransaction,
             txMatcher(
-              dlc.terms.refundLocktime,
+              buildersFor2CETs.first.terms.refundLocktime,
               [
                 getFundOutputWithValue(
                   4, CoinUnit.coin.toSats("2") + sharedDust,

coinlib/test/dlc/ready_test.dart

@@ -0,0 +1,66 @@
+import 'package:coinlib/coinlib.dart';
+import 'package:test/test.dart';
+import '../vectors/keys.dart';
+import 'helpers.dart';
+
+void main() {
+
+  group("DLCReady", () {
+
+    late DLCReady dlc;
+
+    setUpAll(() async {
+
+      await loadCoinlib();
+
+      final builders = List.generate(
+        2,
+        (i) => DLCStatefulBuilder(
+          terms: exampleTerms,
+          ourPublicKey: getPubKey(i),
+        ),
+      );
+
+      final pkg2s = List.generate(
+        2,
+        (i) => builders[i].partOne(
+          packages: {
+            for (int j = 0; j < 2; j++)
+              if (j != i) getPubKey(j): builders[j].publicPackageOne,
+          },
+          privKey: getPrivKey(i),
+        ),
+      );
+
+      dlc = builders.first.partTwo({ getPubKey(1): pkg2s.last });
+
+    });
+
+    test(
+      "cets is immutable",
+      () => expect(
+        () => dlc.cets.remove(exampleTerms.outcomes.keys.first),
+        throwsA(anything),
+      ),
+    );
+
+    test("can read and write", () {
+
+      final readDlc = DLCReady.fromBytes(dlc.toBytes());
+      expect(readDlc.refundTransaction.toHex(), dlc.refundTransaction.toHex());
+
+      for (
+        final f in <Writable Function(CETReady)>[
+          (cet) => cet.tx,
+          (cet) => cet.adaptorSig,
+        ]
+      ) {
+        Iterable<String> cetsToHex(DLCReady dlc)
+          => dlc.cets.values.map((cet) => f(cet).toHex());
+        expect(cetsToHex(readDlc), unorderedMatches(cetsToHex(dlc)));
+      }
+    });
+
+  });
+
+}