refactor: reverse trait system (#255)

* refactor: remove serde feature gate

first step to refactor serde in this library.

* refactor: remove unnecessary trait bonds on FeeStrat.

* fix: remove optional serde to fix compilation

* refactor: simplify crypto types

Simplify trait bounds on TaggedElement and take direct generic on
AccordantKeys and AccordandKeySet instead of nested generic.

* feat: add more primitive derives

* doc: fix missing link

* refactor: rename accordant keys fields

* feat: add serde derive on remaining types

* refactor: script types to disentangle generics

* refactor: new protocol mod and message generics

Move protocol_message into the new protocol module. Modify the generic
argument to split the context into multiple generic. Add more derives on
types.

This commit prepare the removing of bundles from core. They are in fact
messages created inside node already. It also prepare the migration of
execution logic on Alice and Bob into the new protocol module.

* refactor: migrate protocol execution logic

Alice and Bob logic is migrated into protocol module.

* refactor(lib)!: refactor all traits in lib

This huge refactor rework all the trait system used in the library to
push types to the surface instead of having one context: Swap.

This allows more flexibility but refactor is not completly done, some
trait should be removed and some should be split, e.g. crypto::Sign, to
allow less generics in protocol functions.

This refactor allows proper implementation/derivation on messages that
are used in node and passed over the network.

* re-enable taproot module

* ci: fix test unknown serde feat

* chore: remove commented bundles

* chore: remove commented code

* fix: reimplement Encodable/Decodable on Bob

Author: h4sh3d

.github/workflows/test.yml

@@ -34,7 +34,7 @@ jobs:
 
     - uses: Swatinem/rust-cache@v1.4.0
 
-    - run: cargo test --features serde --verbose
+    - run: cargo test --verbose
 
   rpc-test:
     name: Integration tests

Cargo.toml

@@ -25,7 +25,6 @@ rust-version = "1.56.1"
 rpc = []
 experimental = ["ecdsa_fun", "secp256kfun", "rand", "sha2", "rand_chacha", "bincode"]
 taproot = []
-serde = ["serde_crate", "bitcoin/use-serde", "monero/serde_support", "inet2_addr/serde"]
 
 default = ["experimental", "taproot"]
 
@@ -36,9 +35,9 @@ bitcoin_hashes = { version = "0.10" }
 bitvec = { version = "1.0" }
 fixed-hash = { version = "0.7", default-features = false }
 hex = "0.4"
-inet2_addr = { version = "0.6", default-features = false, features = ["tor", "strict_encoding"] }
+inet2_addr = { version = "0.6", default-features = false, features = ["tor", "strict_encoding", "serde"] }
 lightning_encoding = "0.6"
-serde_crate = { package = "serde", version = "1", features = ["derive"], optional = true }
+serde = { version = "1", features = ["derive"] }
 strict_encoding = "1.8"
 strict_encoding_derive = "1.7"
 thiserror = "1"
@@ -47,7 +46,7 @@ tiny-keccak = { version = "2", features = ["keccak"] }
 # crypto libs
 
 bincode = { version = "1", optional = true }
-curve25519-dalek = "3"
+curve25519-dalek = { version = "3", features = ["serde"] }
 ecdsa_fun = { git = "https://github.com/farcaster-project/secp256kfun.git", branch = "secp256k1/0.22", default-features = false, features = ["all"], optional = true }
 rand = { version = "0.8.4", optional = true }
 rand_alt = { package = "rand", version = "0.7.3", features = ["std"] }
@@ -57,8 +56,8 @@ sha2 = { version = "0.9", optional = true }
 sha3 = "0.10"
 
 # blockchain specific
-bitcoin = "0.28.0"
-monero = { version = "0.16" }
+bitcoin = { version = "0.28", features = ["use-serde"] }
+monero = { version = "0.17", features = ["serde"] }
 
 [dev-dependencies]
 bitcoincore-rpc = "0.15"

src/bitcoin/fee.rs

@@ -32,7 +32,7 @@ use std::str::FromStr;
 /// An amount of Bitcoin (internally in satoshis) representing the number of satoshis per virtual
 /// byte a transaction must use for its fee. A [`FeeStrategy`] can use one of more of this type
 /// depending of its complexity (fixed, range, etc).
-#[derive(Debug, Clone, PartialOrd, PartialEq, Eq, Display)]
+#[derive(Debug, Clone, Copy, PartialOrd, PartialEq, Eq, Display)]
 #[display(display_sats_per_vbyte)]
 pub struct SatPerVByte(Amount);
 
@@ -117,22 +117,24 @@ fn get_available_input_sat(tx: &PartiallySignedTransaction) -> Result<Amount, Fe
     ))
 }
 
-impl<S: Strategy> Fee for Bitcoin<S> {
+impl Fee for PartiallySignedTransaction {
     type FeeUnit = SatPerVByte;
 
+    type Amount = Amount;
+
     /// Calculates and sets the fees on the given transaction and return the fees set
     fn set_fee(
-        tx: &mut PartiallySignedTransaction,
+        &mut self,
         strategy: &FeeStrategy<SatPerVByte>,
         politic: FeePriority,
-    ) -> Result<Amount, FeeStrategyError> {
-        if tx.unsigned_tx.output.len() != 1 {
+    ) -> Result<Self::Amount, FeeStrategyError> {
+        if self.unsigned_tx.output.len() != 1 {
             return Err(FeeStrategyError::new(
                 transaction::Error::MultiUTXOUnsuported,
             ));
         }
 
-        let input_sum = get_available_input_sat(tx)?;
+        let input_sum = get_available_input_sat(self)?;
 
         // FIXME This does not account for witnesses
         // currently the fees are wrong
@@ -142,7 +144,7 @@ impl<S: Strategy> Fee for Bitcoin<S> {
         // times four. For transactions with a witness, this is the non-witness
         // consensus-serialized size multiplied by three plus the with-witness consensus-serialized
         // size.
-        let weight = tx.unsigned_tx.weight() as u64;
+        let weight = self.unsigned_tx.weight() as u64;
 
         // Compute the fee amount to set in total
         let fee_amount = match strategy {
@@ -155,7 +157,7 @@ impl<S: Strategy> Fee for Bitcoin<S> {
         .ok_or(FeeStrategyError::AmountOfFeeTooHigh)?;
 
         // Apply the fee on the first output
-        tx.unsigned_tx.output[0].value = input_sum
+        self.unsigned_tx.output[0].value = input_sum
             .checked_sub(fee_amount)
             .ok_or(FeeStrategyError::NotEnoughAssets)?
             .as_sat();
@@ -165,22 +167,19 @@ impl<S: Strategy> Fee for Bitcoin<S> {
     }
 
     /// Validates that the fees for the given transaction are set accordingly to the strategy
-    fn validate_fee(
-        tx: &PartiallySignedTransaction,
-        strategy: &FeeStrategy<SatPerVByte>,
-    ) -> Result<bool, FeeStrategyError> {
-        if tx.unsigned_tx.output.len() != 1 {
+    fn validate_fee(&self, strategy: &FeeStrategy<SatPerVByte>) -> Result<bool, FeeStrategyError> {
+        if self.unsigned_tx.output.len() != 1 {
             return Err(FeeStrategyError::new(
                 transaction::Error::MultiUTXOUnsuported,
             ));
         }
 
-        let input_sum = get_available_input_sat(tx)?.as_sat();
-        let output_sum = tx.unsigned_tx.output[0].value;
+        let input_sum = get_available_input_sat(self)?.as_sat();
+        let output_sum = self.unsigned_tx.output[0].value;
         let fee = input_sum
             .checked_sub(output_sum)
             .ok_or(FeeStrategyError::AmountOfFeeTooHigh)?;
-        let weight = tx.unsigned_tx.weight() as u64;
+        let weight = self.unsigned_tx.weight() as u64;
 
         let effective_sat_per_vbyte = SatPerVByte::from_sat(
             weight

src/bitcoin/segwitv0.rs

@@ -11,17 +11,19 @@ use crate::bitcoin::transaction::TxInRef;
 use crate::bitcoin::transaction::{MetadataOutput, Tx};
 use crate::bitcoin::{Bitcoin, BitcoinSegwitV0, Btc, Strategy};
 
+use crate::bitcoin::timelock::CSVTimelock;
 use crate::blockchain::Transactions;
 use crate::consensus::{self, CanonicalBytes};
-use crate::crypto::{Keys, SharedKeyId, SharedSecretKeys, Signatures};
-use crate::role::{Arbitrating, SwapRole};
+use crate::crypto::{DeriveKeys, SharedKeyId, Signatures};
+use crate::role::SwapRole;
 use crate::script::{DataLock, DataPunishableLock, DoubleKeys, ScriptPath};
 
 use bitcoin::blockdata::opcodes;
 use bitcoin::blockdata::script::{Builder, Instruction, Script};
 use bitcoin::blockdata::transaction::EcdsaSighashType;
 use bitcoin::hashes::sha256d::Hash as Sha256dHash;
 use bitcoin::secp256k1::{ecdsa::Signature, Message, PublicKey, Secp256k1, SecretKey, Signing};
+use bitcoin::util::psbt::PartiallySignedTransaction;
 use bitcoin::util::sighash::SighashCache;
 
 use ecdsa_fun::adaptor::EncryptedSignature;
@@ -86,20 +88,20 @@ pub struct CoopLock {
 }
 
 impl CoopLock {
-    pub fn script(data: DataLock<BitcoinSegwitV0>) -> Script {
+    pub fn script(data: DataLock<CSVTimelock, PublicKey>) -> Script {
         let DataLock {
             success: DoubleKeys { alice, bob },
             ..
         } = data;
         Builder::new()
-            .push_key(&bitcoin::util::key::PublicKey::new(*alice))
+            .push_key(&bitcoin::util::key::PublicKey::new(alice))
             .push_opcode(opcodes::all::OP_CHECKSIGVERIFY)
-            .push_key(&bitcoin::util::key::PublicKey::new(*bob))
+            .push_key(&bitcoin::util::key::PublicKey::new(bob))
             .push_opcode(opcodes::all::OP_CHECKSIG)
             .into_script()
     }
 
-    pub fn v0_p2wsh(data: DataLock<BitcoinSegwitV0>) -> Script {
+    pub fn v0_p2wsh(data: DataLock<CSVTimelock, PublicKey>) -> Script {
         Self::script(data).to_v0_p2wsh()
     }
 
@@ -177,29 +179,29 @@ pub struct PunishLock {
 }
 
 impl PunishLock {
-    pub fn script(data: DataPunishableLock<BitcoinSegwitV0>) -> Script {
+    pub fn script(data: DataPunishableLock<CSVTimelock, PublicKey>) -> Script {
         let DataPunishableLock {
             timelock,
             success: DoubleKeys { alice, bob },
             failure,
         } = data;
         Builder::new()
             .push_opcode(opcodes::all::OP_IF)
-            .push_key(&bitcoin::util::key::PublicKey::new(*alice))
+            .push_key(&bitcoin::util::key::PublicKey::new(alice))
             .push_opcode(opcodes::all::OP_CHECKSIGVERIFY)
-            .push_key(&bitcoin::util::key::PublicKey::new(*bob))
+            .push_key(&bitcoin::util::key::PublicKey::new(bob))
             .push_opcode(opcodes::all::OP_CHECKSIG)
             .push_opcode(opcodes::all::OP_ELSE)
             .push_int(timelock.as_u32().into())
             .push_opcode(opcodes::all::OP_CSV)
             .push_opcode(opcodes::all::OP_DROP)
-            .push_key(&bitcoin::util::key::PublicKey::new(*failure))
+            .push_key(&bitcoin::util::key::PublicKey::new(failure))
             .push_opcode(opcodes::all::OP_CHECKSIG)
             .push_opcode(opcodes::all::OP_ENDIF)
             .into_script()
     }
 
-    pub fn v0_p2wsh(data: DataPunishableLock<BitcoinSegwitV0>) -> Script {
+    pub fn v0_p2wsh(data: DataPunishableLock<CSVTimelock, PublicKey>) -> Script {
         Self::script(data).to_v0_p2wsh()
     }
 
@@ -336,7 +338,7 @@ impl PunishLock {
     }
 }
 
-impl Arbitrating for Bitcoin<SegwitV0> {}
+//impl Arbitrating for Bitcoin<SegwitV0> {}
 
 impl TryFrom<Btc> for Bitcoin<SegwitV0> {
     type Error = consensus::Error;
@@ -350,7 +352,15 @@ impl TryFrom<Btc> for Bitcoin<SegwitV0> {
 }
 
 impl Transactions for Bitcoin<SegwitV0> {
-    type Metadata = MetadataOutput;
+    type Addr = bitcoin::Address;
+    type Amt = bitcoin::Amount;
+    type Tx = bitcoin::Transaction;
+    type Px = PartiallySignedTransaction;
+    type Out = MetadataOutput;
+    type Ti = CSVTimelock;
+    type Ms = Sha256dHash;
+    type Pk = PublicKey;
+    type Si = Signature;
 
     type Funding = Funding;
     type Lock = Tx<Lock>;
@@ -360,14 +370,19 @@ impl Transactions for Bitcoin<SegwitV0> {
     type Punish = Tx<Punish>;
 }
 
-impl Keys for Bitcoin<SegwitV0> {
-    type SecretKey = SecretKey;
+impl DeriveKeys for Bitcoin<SegwitV0> {
     type PublicKey = PublicKey;
+    type PrivateKey = SecretKey;
 
-    fn extra_keys() -> Vec<u16> {
+    fn extra_public_keys() -> Vec<u16> {
         // No extra key
         vec![]
     }
+
+    fn extra_shared_private_keys() -> Vec<SharedKeyId> {
+        // No shared key in Bitcoin, transparent ledger
+        vec![]
+    }
 }
 
 impl CanonicalBytes for SecretKey {
@@ -383,28 +398,6 @@ impl CanonicalBytes for SecretKey {
     }
 }
 
-impl CanonicalBytes for PublicKey {
-    fn as_canonical_bytes(&self) -> Vec<u8> {
-        self.serialize().as_ref().into()
-    }
-
-    fn from_canonical_bytes(bytes: &[u8]) -> Result<Self, consensus::Error>
-    where
-        Self: Sized,
-    {
-        PublicKey::from_slice(bytes).map_err(consensus::Error::new)
-    }
-}
-
-impl SharedSecretKeys for Bitcoin<SegwitV0> {
-    type SharedSecretKey = SecretKey;
-
-    fn shared_keys() -> Vec<SharedKeyId> {
-        // No shared key in Bitcoin, transparent ledger
-        vec![]
-    }
-}
-
 impl Signatures for Bitcoin<SegwitV0> {
     type Message = Sha256dHash;
     type Signature = Signature;

src/bitcoin/segwitv0/buy.rs

@@ -3,15 +3,20 @@ use std::marker::PhantomData;
 use bitcoin::blockdata::transaction::{TxIn, TxOut};
 use bitcoin::blockdata::witness::Witness;
 use bitcoin::secp256k1::ecdsa::Signature;
+use bitcoin::secp256k1::PublicKey;
 use bitcoin::util::ecdsa::EcdsaSig;
 use bitcoin::util::psbt::PartiallySignedTransaction;
 use bitcoin::Address;
+use bitcoin::Amount;
+use bitcoin::Transaction;
 
 use crate::role::SwapRole;
 use crate::script;
 use crate::transaction::{Buyable, Error as FError, Lockable};
 
+use crate::bitcoin::segwitv0::Sha256dHash;
 use crate::bitcoin::segwitv0::{CoopLock, SegwitV0};
+use crate::bitcoin::timelock::CSVTimelock;
 use crate::bitcoin::transaction::{Error, MetadataOutput, SubTransaction, Tx};
 use crate::bitcoin::Bitcoin;
 
@@ -53,10 +58,32 @@ impl SubTransaction for Buy {
     }
 }
 
-impl Buyable<Bitcoin<SegwitV0>, MetadataOutput> for Tx<Buy> {
+impl
+    Buyable<
+        Address,
+        Transaction,
+        PartiallySignedTransaction,
+        MetadataOutput,
+        Amount,
+        CSVTimelock,
+        Sha256dHash,
+        PublicKey,
+        Signature,
+    > for Tx<Buy>
+{
     fn initialize(
-        prev: &impl Lockable<Bitcoin<SegwitV0>, MetadataOutput>,
-        _lock: script::DataLock<Bitcoin<SegwitV0>>,
+        prev: &impl Lockable<
+            Address,
+            Transaction,
+            PartiallySignedTransaction,
+            MetadataOutput,
+            Amount,
+            CSVTimelock,
+            Sha256dHash,
+            PublicKey,
+            Signature,
+        >,
+        _lock: script::DataLock<CSVTimelock, PublicKey>,
         destination_target: Address,
     ) -> Result<Self, FError> {
         let output_metadata = prev.get_consumable_output()?;