Infer DAI token from Ethereum chain ID

This introduces the ethereum::Address type into our config::File
struct. Unfortunately, this opens a can of worms with a bug in
the serde-hex library. See [0] for more details.

We work around this by removing the dependency on serde-hex from our
Ethereum deserialization code and instead hand-roll everything for
our usecase.

This also has the advantage that we can now again just use our structs
directly in the route handlers of warp instead of serde_json::Value.
See [1] for more on this.

[0]: fspmarshall/serde-hex#8
[1]: #2405

Author: thomaseizinger

Cargo.lock

@@ -65,10 +65,8 @@ export class E2ETestActorConfig {
         };
     }
 
-    private createLedgerConnectors(
-        ledgerConfig: LedgerConfig
-    ): LedgerConnectors {
-        const config: LedgerConnectors = {};
+    private createLedgerConnectors(ledgerConfig: LedgerConfig): LedgerConfigs {
+        const config: LedgerConfigs = {};
 
         if (ledgerConfig.bitcoin) {
             config.bitcoin = bitcoinConnector(ledgerConfig.bitcoin);
@@ -106,26 +104,31 @@ export class E2ETestActorConfig {
     }
 }
 
-interface LedgerConnectors {
-    bitcoin?: BitcoinConnector;
-    ethereum?: EthereumConnector;
-    lightning?: LightningConnector;
+interface LedgerConfigs {
+    bitcoin?: BitcoinConfig;
+    ethereum?: EthereumConfig;
+    lightning?: LightningConfig;
 }
 
 interface Geth {
     node_url: string;
 }
 
-interface EthereumConnector {
+interface EthereumConfig {
     chain_id: number;
     geth: Geth;
+    tokens: Tokens;
+}
+
+interface Tokens {
+    dai: string;
 }
 
 interface Bitcoind {
     node_url: string;
 }
 
-interface BitcoinConnector {
+interface BitcoinConfig {
     network: string;
     bitcoind: Bitcoind;
 }
@@ -135,12 +138,12 @@ interface Lnd {
     dir: string;
 }
 
-interface LightningConnector {
+interface LightningConfig {
     network: string;
     lnd: Lnd;
 }
 
-function bitcoinConnector(nodeConfig: BitcoinNodeConfig): BitcoinConnector {
+function bitcoinConnector(nodeConfig: BitcoinNodeConfig): BitcoinConfig {
     return {
         bitcoind: {
             node_url: nodeConfig.rpcUrl,
@@ -149,18 +152,19 @@ function bitcoinConnector(nodeConfig: BitcoinNodeConfig): BitcoinConnector {
     };
 }
 
-function ethereumConnector(nodeConfig: EthereumNodeConfig): EthereumConnector {
+function ethereumConnector(nodeConfig: EthereumNodeConfig): EthereumConfig {
     return {
         chain_id: nodeConfig.chain_id,
         geth: {
             node_url: nodeConfig.rpc_url,
         },
+        tokens: {
+            dai: nodeConfig.tokenContract,
+        },
     };
 }
 
-function lightningConnector(
-    nodeConfig: LightningNodeConfig
-): LightningConnector {
+function lightningConnector(nodeConfig: LightningNodeConfig): LightningConfig {
     return {
         network: "regtest",
         lnd: {

api_tests/src/config.ts

@@ -3,7 +3,7 @@ mod serde_bitcoin_network;
 mod settings;
 mod validation;
 
-use crate::{ethereum::ChainId, fs};
+use crate::{ethereum, ethereum::ChainId, fs};
 use anyhow::{Context, Result};
 use conquer_once::Lazy;
 use libp2p::Multiaddr;
@@ -25,6 +25,18 @@ static LND_URL: Lazy<Url> = Lazy::new(|| parse_unchecked("https://localhost:8080
 
 static WEB3_URL: Lazy<Url> = Lazy::new(|| parse_unchecked("http://localhost:8545"));
 
+/// The DAI token contract on Ethereum mainnet.
+///
+/// Source: https://developer.makerdao.com/dai/1/api/
+static DAI_MAINNET: Lazy<ethereum::Address> =
+    Lazy::new(|| parse_unchecked("0x6b175474e89094c44da98b954eedeac495271d0f"));
+
+/// The DAI token contract on the Ethereum testnet "kovan".
+///
+/// Source: https://developer.makerdao.com/dai/1/api/
+static DAI_KOVAN: Lazy<ethereum::Address> =
+    Lazy::new(|| parse_unchecked("0xc4375b7de8af5a38a93548eb8453a498222c4ff2"));
+
 static COMIT_SOCKET: Lazy<Multiaddr> = Lazy::new(|| parse_unchecked("/ip4/0.0.0.0/tcp/9939"));
 
 #[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
@@ -118,14 +130,16 @@ impl From<Bitcoin> for file::Bitcoin {
 pub struct Ethereum {
     pub chain_id: ChainId,
     pub geth: Geth,
+    pub tokens: Tokens,
 }
 
 impl Ethereum {
-    fn new(chain_id: ChainId) -> Self {
-        Self {
+    fn new(chain_id: ChainId) -> Result<Ethereum> {
+        Ok(Self {
             chain_id,
             geth: Geth::new(),
-        }
+            tokens: Tokens::new(chain_id)?,
+        })
     }
 
     fn from_file(ethereum: file::Ethereum, comit_network: Option<comit::Network>) -> Result<Self> {
@@ -143,8 +157,16 @@ impl Ethereum {
 
         let chain_id = ethereum.chain_id;
         let geth = ethereum.geth.unwrap_or_else(Geth::new);
+        let tokens = ethereum.tokens.map_or_else(
+            || Tokens::new(chain_id),
+            |file| Tokens::from_file(file, chain_id),
+        )?;
 
-        Ok(Ethereum { chain_id, geth })
+        Ok(Ethereum {
+            chain_id,
+            geth,
+            tokens,
+        })
     }
 }
 
@@ -153,6 +175,15 @@ impl From<Ethereum> for file::Ethereum {
         file::Ethereum {
             chain_id: ethereum.chain_id,
             geth: Some(ethereum.geth),
+            tokens: Some(ethereum.tokens.into()),
+        }
+    }
+}
+
+impl From<Tokens> for file::Tokens {
+    fn from(tokens: Tokens) -> Self {
+        file::Tokens {
+            dai: Some(tokens.dai),
         }
     }
 }
@@ -170,6 +201,36 @@ impl Geth {
     }
 }
 
+#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
+pub struct Tokens {
+    pub dai: ethereum::Address,
+}
+
+impl Tokens {
+    fn new(chain_id: ChainId) -> Result<Self> {
+        let dai = dai_address_from_chain_id(chain_id)?;
+
+        Ok(Self { dai })
+    }
+
+    fn from_file(file: file::Tokens, id: ChainId) -> Result<Self> {
+        let dai = file.dai.map_or_else(|| dai_address_from_chain_id(id), Ok)?;
+
+        Ok(Self { dai })
+    }
+}
+
+fn dai_address_from_chain_id(id: ChainId) -> Result<ethereum::Address> {
+    Ok(match id {
+        ChainId::MAINNET => *DAI_MAINNET,
+        ChainId::KOVAN => *DAI_KOVAN,
+        id => anyhow::bail!(
+            "unable to infer DAI token contract from chain-ID {}",
+            u32::from(id)
+        ),
+    })
+}
+
 #[derive(Clone, Debug, PartialEq, Serialize)]
 pub struct Lightning {
     pub network: bitcoin::Network,

cnd/src/config.rs

@@ -1,5 +1,6 @@
 use crate::{
     config::{Bitcoind, Data, Geth, Network},
+    ethereum,
     ethereum::ChainId,
 };
 use log::LevelFilter;
@@ -37,6 +38,12 @@ pub struct Bitcoin {
 pub struct Ethereum {
     pub chain_id: ChainId,
     pub geth: Option<Geth>,
+    pub tokens: Option<Tokens>,
+}
+
+#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
+pub struct Tokens {
+    pub dai: Option<ethereum::Address>,
 }
 
 #[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
@@ -230,6 +237,9 @@ chain_id = 1337
 [ethereum.geth]
 node_url = "http://localhost:8545/"
 
+[ethereum.tokens]
+dai = "0x6b175474e89094c44da98b954eedeac495271d0f"
+
 [lightning]
 network = "regtest"
 
@@ -264,6 +274,13 @@ dir = "/foo/bar"
                 geth: Some(Geth {
                     node_url: "http://localhost:8545".parse().unwrap(),
                 }),
+                tokens: Some(Tokens {
+                    dai: Some(
+                        "0x6b175474e89094c44da98b954eedeac495271d0f"
+                            .parse()
+                            .unwrap(),
+                    ),
+                }),
             }),
             lightning: Some(Lightning {
                 network: bitcoin::Network::Regtest,
@@ -350,40 +367,67 @@ dir = "/foo/bar"
     fn ethereum_deserializes_correctly() {
         let file_contents = vec![
             r#"
-            chain_id = 1337
+            chain_id = 42
             [geth]
             node_url = "http://example.com:8545"
+            [tokens]
+            dai = "0xc4375b7de8af5a38a93548eb8453a498222c4ff2"
             "#,
             r#"
             chain_id = 3
             [geth]
             node_url = "http://example.com:8545"
+            [tokens]
+            dai = "0xaD6D458402F60fD3Bd25163575031ACDce07538D"
             "#,
             r#"
             chain_id = 1
             [geth]
             node_url = "http://example.com:8545"
+            [tokens]
+            dai = "0x6b175474e89094c44da98b954eedeac495271d0f"
             "#,
         ];
 
         let expected = vec![
             Ethereum {
-                chain_id: ChainId::GETH_DEV,
+                chain_id: ChainId::KOVAN,
                 geth: Some(Geth {
                     node_url: Url::parse("http://example.com:8545").unwrap(),
                 }),
+                tokens: Some(Tokens {
+                    dai: Some(
+                        "0xc4375b7de8af5a38a93548eb8453a498222c4ff2"
+                            .parse()
+                            .unwrap(),
+                    ),
+                }),
             },
             Ethereum {
                 chain_id: ChainId::ROPSTEN,
                 geth: Some(Geth {
                     node_url: Url::parse("http://example.com:8545").unwrap(),
                 }),
+                tokens: Some(Tokens {
+                    dai: Some(
+                        "0xaD6D458402F60fD3Bd25163575031ACDce07538D"
+                            .parse()
+                            .unwrap(),
+                    ),
+                }),
             },
             Ethereum {
                 chain_id: ChainId::MAINNET,
                 geth: Some(Geth {
                     node_url: Url::parse("http://example.com:8545").unwrap(),
                 }),
+                tokens: Some(Tokens {
+                    dai: Some(
+                        "0x6b175474e89094c44da98b954eedeac495271d0f"
+                            .parse()
+                            .unwrap(),
+                    ),
+                }),
             },
         ];
 

cnd/src/config/file.rs

@@ -154,7 +154,7 @@ impl Settings {
                 |file| Bitcoin::from_file(file, comit_network),
             )?,
             ethereum: ethereum.map_or_else(
-                || Ok(Ethereum::new(comit_network.unwrap_or_default().into())),
+                || Ethereum::new(comit_network.unwrap_or_default().into()),
                 |file| Ethereum::from_file(file, comit_network),
             )?,
             lightning: lightning.map_or_else(
@@ -169,7 +169,7 @@ impl Settings {
 mod tests {
     use super::*;
     use crate::{
-        config::{file, Bitcoind, Geth, Lnd},
+        config::{file, Bitcoind, Geth, Lnd, Tokens, DAI_MAINNET},
         ethereum::ChainId,
     };
     use spectral::prelude::*;
@@ -311,6 +311,7 @@ mod tests {
                 geth: Geth {
                     node_url: "http://localhost:8545".parse().unwrap(),
                 },
+                tokens: Tokens { dai: *DAI_MAINNET },
             })
     }
 

cnd/src/config/settings.rs

@@ -8,16 +8,13 @@ use crate::{
     storage::Save,
     Facade, LocalSwapId,
 };
-use serde::Deserialize;
 use warp::{http::StatusCode, Rejection, Reply};
 
 #[allow(clippy::needless_pass_by_value)]
-pub async fn post_swap(body: serde_json::Value, facade: Facade) -> Result<impl Reply, Rejection> {
-    let body = PostBody::<Halbit, Herc20>::deserialize(&body)
-        .map_err(anyhow::Error::new)
-        .map_err(problem::from_anyhow)
-        .map_err(warp::reject::custom)?;
-
+pub async fn post_swap(
+    body: PostBody<Halbit, Herc20>,
+    facade: Facade,
+) -> Result<impl Reply, Rejection> {
     let swap_id = LocalSwapId::default();
     let reply = warp::reply::reply();