Add timestamp to db accepted swaps

Add a column to the two accepted swap tables.  Use SQLite
auto-generation of timestamp to populate this column when an accepted
swap is stored in the database.  Add and test a database function to
retrieve the timestamp for an [accepted] swap id.

Author: Tobin C. Harding

Cargo.lock

@@ -19,7 +19,7 @@ config = { version = "0.9", features = ["toml"] }
 debug_stub_derive = "0.3"
 derivative = "1"
 derive_more = "0.99.2"
-diesel = { version = "1.4", features = ["sqlite"] }
+diesel = { version = "1.4", features = ["sqlite", "chrono"] }
 diesel_migrations = "1.4.0"
 directories = "2.0"
 either = "1.5"

cnd/Cargo.toml

@@ -71,15 +71,17 @@ CREATE TABLE rfc003_ethereum_bitcoin_accept_messages
     id INTEGER               NOT NULL PRIMARY KEY,
     swap_id UNIQUE           NOT NULL,
     bitcoin_refund_identity  NOT NULL,
-    ethereum_redeem_identity NOT NULL
+    ethereum_redeem_identity NOT NULL,
+    at DATETIME DEFAULT CURRENT_TIMESTAMP
 );
 
 CREATE TABLE rfc003_bitcoin_ethereum_accept_messages
 (
     id INTEGER               NOT NULL PRIMARY KEY,
     swap_id UNIQUE           NOT NULL,
     bitcoin_redeem_identity  NOT NULL,
-    ethereum_refund_identity NOT NULL
+    ethereum_refund_identity NOT NULL,
+    at DATETIME DEFAULT CURRENT_TIMESTAMP
 );
 
 CREATE TABLE rfc003_decline_messages

cnd/migrations/2019-11-11-034058_create-message-tables/up.sql

@@ -54,17 +54,17 @@ macro_rules! db_roundtrip_test {
                         db.save(saved_accept.clone()).await?;
 
                         let loaded_swap = Retrieve::get(&db, &swap_id).await?;
-                        let (loaded_request, loaded_accept) = db.load_accepted_swap(&swap_id).await?;
+                        let (loaded_request, loaded_accept, _at) = db.load_accepted_swap(&swap_id).await?;
                         let loaded_swap_types = db.determine_types(&swap_id).await?;
 
                         Ok((loaded_swap, loaded_request, loaded_accept, loaded_swap_types))
                     })?;
 
                     Ok(
                         saved_request == loaded_request &&
-                        saved_accept == loaded_accept &&
-                        loaded_swap == saved_swap &&
-                        loaded_swap_types == expected_swap_types
+                            saved_accept == loaded_accept &&
+                            saved_swap == loaded_swap &&
+                            expected_swap_types == loaded_swap_types
                     )
                 }
 

cnd/src/db/integration_tests.rs

@@ -17,9 +17,10 @@ use crate::{
     timestamp::Timestamp,
 };
 use async_trait::async_trait;
+use chrono::NaiveDateTime;
 use diesel::{self, prelude::*, RunQueryDsl};
 
-pub type AcceptedSwap<AL, BL, AA, BA> = (Request<AL, BL, AA, BA>, Accept<AL, BL>);
+pub type AcceptedSwap<AL, BL, AA, BA> = (Request<AL, BL, AA, BA>, Accept<AL, BL>, NaiveDateTime);
 
 #[async_trait]
 pub trait LoadAcceptedSwap<AL: Ledger, BL: Ledger, AA: Asset, BA: Asset> {
@@ -46,6 +47,8 @@ struct BitcoinEthereumBitcoinEtherAcceptedSwap {
     // Accept fields.
     bitcoin_redeem_identity: Text<bitcoin::PublicKey>,
     ethereum_refund_identity: Text<EthereumAddress>,
+
+    at: NaiveDateTime,
 }
 
 #[async_trait]
@@ -86,6 +89,7 @@ impl LoadAcceptedSwap<Bitcoin, Ethereum, bitcoin::Amount, EtherQuantity> for Sql
                         request_messages::secret_hash,
                         accept_messages::bitcoin_redeem_identity,
                         accept_messages::ethereum_refund_identity,
+                        accept_messages::at,
                     ))
                     .filter(accept_messages::swap_id.eq(key))
                     .first(connection)
@@ -119,6 +123,7 @@ impl LoadAcceptedSwap<Bitcoin, Ethereum, bitcoin::Amount, EtherQuantity> for Sql
                 ),
                 beta_ledger_refund_identity: (record.ethereum_refund_identity.0).0,
             },
+            record.at,
         ))
     }
 }
@@ -140,6 +145,8 @@ struct EthereumBitcoinEtherBitcoinAcceptedSwap {
     // Accept fields.
     ethereum_redeem_identity: Text<EthereumAddress>,
     bitcoin_refund_identity: Text<bitcoin::PublicKey>,
+
+    at: NaiveDateTime,
 }
 
 #[async_trait]
@@ -178,6 +185,7 @@ impl LoadAcceptedSwap<Ethereum, Bitcoin, EtherQuantity, bitcoin::Amount> for Sql
                         request_messages::secret_hash,
                         accept_messages::ethereum_redeem_identity,
                         accept_messages::bitcoin_refund_identity,
+                        accept_messages::at,
                     ))
                     .filter(accept_messages::swap_id.eq(key))
                     .first(connection)
@@ -211,6 +219,7 @@ impl LoadAcceptedSwap<Ethereum, Bitcoin, EtherQuantity, bitcoin::Amount> for Sql
                     *record.bitcoin_refund_identity,
                 ),
             },
+            record.at,
         ))
     }
 }
@@ -233,6 +242,8 @@ struct BitcoinEthereumBitcoinErc20AcceptedSwap {
     // Accept fields.
     bitcoin_redeem_identity: Text<bitcoin::PublicKey>,
     ethereum_refund_identity: Text<EthereumAddress>,
+
+    at: NaiveDateTime,
 }
 
 #[async_trait]
@@ -272,6 +283,7 @@ impl LoadAcceptedSwap<Bitcoin, Ethereum, bitcoin::Amount, Erc20Token> for Sqlite
                         request_messages::secret_hash,
                         accept_messages::bitcoin_redeem_identity,
                         accept_messages::ethereum_refund_identity,
+                        accept_messages::at,
                     ))
                     .filter(accept_messages::swap_id.eq(key))
                     .first(connection)
@@ -308,6 +320,7 @@ impl LoadAcceptedSwap<Bitcoin, Ethereum, bitcoin::Amount, Erc20Token> for Sqlite
                 ),
                 beta_ledger_refund_identity: (record.ethereum_refund_identity.0).0,
             },
+            record.at,
         ))
     }
 }
@@ -330,6 +343,8 @@ struct EthereumBitcoinErc20BitcoinAcceptedSwap {
     // Accept fields.
     ethereum_redeem_identity: Text<EthereumAddress>,
     bitcoin_refund_identity: Text<bitcoin::PublicKey>,
+
+    at: NaiveDateTime,
 }
 
 #[async_trait]
@@ -369,6 +384,7 @@ impl LoadAcceptedSwap<Ethereum, Bitcoin, Erc20Token, bitcoin::Amount> for Sqlite
                         request_messages::secret_hash,
                         accept_messages::ethereum_redeem_identity,
                         accept_messages::bitcoin_refund_identity,
+                        accept_messages::at,
                     ))
                     .filter(accept_messages::swap_id.eq(key))
                     .first(connection)
@@ -405,6 +421,7 @@ impl LoadAcceptedSwap<Ethereum, Bitcoin, Erc20Token, bitcoin::Amount> for Sqlite
                     *record.bitcoin_refund_identity,
                 ),
             },
+            record.at,
         ))
     }
 }

cnd/src/db/load_swaps.rs

@@ -86,7 +86,7 @@ impl Sqlite {
     async fn role(&self, key: &SwapId) -> anyhow::Result<Role> {
         use self::schema::rfc003_swaps as swaps;
 
-        let record: QueryableSwap = self
+        let record: QueryableSwapRole = self
             .do_in_transaction(|connection| {
                 let key = Text(key);
 
@@ -118,7 +118,7 @@ fn ensure_folder_tree_exists(path: &Path) -> anyhow::Result<()> {
 }
 
 #[derive(Queryable, Debug, Clone, PartialEq)]
-struct QueryableSwap {
+struct QueryableSwapRole {
     pub swap_id: Text<SwapId>,
     pub role: Text<Role>,
 }

cnd/src/db/mod.rs

@@ -317,6 +317,7 @@ impl Save<Request<Ethereum, Bitcoin, Erc20Token, bitcoin::Amount>> for Sqlite {
         Ok(())
     }
 }
+
 #[derive(Insertable, Debug, Copy, Clone)]
 #[table_name = "rfc003_ethereum_bitcoin_accept_messages"]
 struct InsertableEthereumBitcoinAcceptMessage {

cnd/src/db/save.rs

@@ -74,6 +74,7 @@ table! {
        swap_id -> Text,
        ethereum_redeem_identity -> Text,
        bitcoin_refund_identity -> Text,
+       at -> Timestamp,
    }
 }
 
@@ -83,6 +84,7 @@ table! {
        swap_id -> Text,
        bitcoin_redeem_identity -> Text,
        ethereum_refund_identity -> Text,
+       at -> Timestamp,
    }
 }
 

cnd/src/db/schema.rs

@@ -33,7 +33,7 @@ pub async fn load_swaps_from_database(
                 db.load_accepted_swap(&swap_id).await;
 
             match accepted {
-                Ok((request, accept)) => {
+                Ok((request, accept, _at)) => {
                     match types.role {
                         Role::Alice => {
                             let state = alice::State::accepted(request.clone(), accept, seed);

cnd/src/load_swaps.rs

@@ -0,0 +1,154 @@
+use bitcoin::{self, secp256k1::Secp256k1};
+use chrono::NaiveDateTime;
+use cnd::{
+    bitcoin::PublicKey,
+    db::{AcceptedSwap, LoadAcceptedSwap, Save, Sqlite, Swap},
+    swap_protocols::{
+        ledger::{Bitcoin, Ethereum},
+        rfc003::{Accept, Request, Secret, SecretHash},
+        HashFunction, Role, SwapId,
+    },
+    timestamp::Timestamp,
+};
+use ethereum_support::{Address, EtherQuantity};
+use futures_core::{FutureExt, TryFutureExt};
+use libp2p::PeerId;
+use std::str::FromStr;
+use tokio::{self, runtime::current_thread::Runtime};
+
+#[test]
+fn accepted_swap_has_valid_timestamp() {
+    let mut runtime = Runtime::new().expect("failed to create new runtime");
+
+    let future = accepted_at_for_bitcoin_ethereum();
+    // If this assignment works then we have a valid NaiveDateTime.
+    let _accepted_at = runtime
+        .block_on(future.boxed().compat())
+        .expect("failed to get accepted swap");
+
+    let future = accepted_at_for_ethereum_bitcoin();
+    let _accepted_at = runtime
+        .block_on(future.boxed().compat())
+        .expect("failed to get accepted swap");
+}
+
+async fn accepted_at_for_bitcoin_ethereum() -> anyhow::Result<NaiveDateTime> {
+    let swap_id = swap_id();
+    let role = Role::Alice;
+
+    let db_path = tempfile::Builder::new()
+        .prefix(&swap_id.to_string())
+        .suffix(".sqlite")
+        .tempfile()
+        .unwrap()
+        .into_temp_path();
+    let db = Sqlite::new(&db_path).expect("db");
+
+    let swap = swap(swap_id, role);
+    db.save(swap).await?;
+
+    let request = Request {
+        swap_id,
+        alpha_ledger: Bitcoin::default(),
+        beta_ledger: Ethereum::default(),
+        alpha_asset: bitcoin::Amount::default(),
+        beta_asset: EtherQuantity::zero(),
+        hash_function: HashFunction::Sha256,
+        alpha_ledger_refund_identity: bitcoin_address(),
+        beta_ledger_redeem_identity: ethereum_address(),
+        alpha_expiry: Timestamp::now(),
+        beta_expiry: Timestamp::now(),
+        secret_hash: secret_hash(),
+    };
+    db.save(request).await?;
+
+    let accept: Accept<Bitcoin, Ethereum> = Accept {
+        swap_id: swap_id.clone(),
+        beta_ledger_refund_identity: ethereum_address(), // This is non-sense but fine for this test
+        alpha_ledger_redeem_identity: bitcoin_address(), // same address for refund/redeem.
+    };
+    db.save(accept).await?;
+
+    let accepted_swap: AcceptedSwap<Bitcoin, Ethereum, bitcoin::Amount, EtherQuantity> =
+        db.load_accepted_swap(&swap_id).await?;
+
+    let (_request, _accept, at) = accepted_swap;
+
+    Ok(at)
+}
+
+async fn accepted_at_for_ethereum_bitcoin() -> anyhow::Result<NaiveDateTime> {
+    let swap_id = swap_id();
+    let role = Role::Bob;
+
+    let db_path = tempfile::Builder::new()
+        .prefix(&swap_id.to_string())
+        .suffix(".sqlite")
+        .tempfile()
+        .unwrap()
+        .into_temp_path();
+    let db = Sqlite::new(&db_path).expect("db");
+
+    let swap = swap(swap_id.clone(), role);
+    db.save(swap).await?;
+
+    let request = Request {
+        swap_id: swap_id.clone(),
+        alpha_ledger: Ethereum::default(),
+        beta_ledger: Bitcoin::default(),
+        alpha_asset: EtherQuantity::zero(),
+        beta_asset: bitcoin::Amount::default(),
+        hash_function: HashFunction::Sha256,
+        alpha_ledger_refund_identity: ethereum_address(),
+        beta_ledger_redeem_identity: bitcoin_address(),
+        alpha_expiry: Timestamp::now(),
+        beta_expiry: Timestamp::now(),
+        secret_hash: secret_hash(),
+    };
+    db.save(request).await?;
+
+    let accept: Accept<Ethereum, Bitcoin> = Accept {
+        swap_id: swap_id.clone(),
+        beta_ledger_refund_identity: bitcoin_address(), // This is non-sense but fine for this test
+        alpha_ledger_redeem_identity: ethereum_address(), // same address for refund/redeem.
+    };
+    db.save(accept).await?;
+
+    let accepted_swap: AcceptedSwap<Ethereum, Bitcoin, EtherQuantity, bitcoin::Amount> =
+        db.load_accepted_swap(&swap_id).await?;
+
+    let (_request, _accept, at) = accepted_swap;
+
+    Ok(at)
+}
+
+fn swap_id() -> SwapId {
+    SwapId::from_str("0123456789abcdef0123456789abcdef").unwrap()
+}
+
+fn swap(swap_id: SwapId, role: Role) -> Swap {
+    Swap {
+        swap_id,
+        role,
+        counterparty: PeerId::random(),
+    }
+}
+
+fn bitcoin_address() -> PublicKey {
+    let s = Secp256k1::new();
+    let sk = bitcoin::PrivateKey::from_str("cVt4o7BGAig1UXywgGSmARhxMdzP5qvQsxKkSsc1XEkw3tDTQFpy")
+        .unwrap();
+    let pk = bitcoin::PublicKey::from_private_key(&s, &sk);
+
+    PublicKey::from(pk)
+}
+
+fn ethereum_address() -> Address {
+    Address::from_str("0A81e8be41b21f651a71aaB1A85c6813b8bBcCf8").unwrap()
+}
+
+fn secret_hash() -> SecretHash {
+    let bytes = b"hello world, you are beautiful!!";
+    let secret = Secret::from(*bytes);
+    secret.hash()
+}