fix: session_from_token contract call

Author: samparsky

adapter/src/ethereum.rs

@@ -160,7 +160,7 @@ impl Adapter for EthereumAdapter {
                 None,
             )
             .wait()
-            .map_err(|e| map_error("contract channel status query failed"))?;
+            .map_err(|_| map_error("contract channel status query failed"))?;
 
         if channel_status != *CHANNEL_STATE_ACTIVE {
             return Err(AdapterError::Configuration(
@@ -203,14 +203,16 @@ impl Adapter for EthereumAdapter {
 
         let sess = match &verified.payload.identity {
             Some(identity) => {
-                let contract_address = Address::from_slice(identity.as_bytes());
-                let contract = get_contract(&self.config, contract_address, &IDENTITY_ABI)
-                    .map_err(|_| map_error("failed to init identity contract"))?;
+
+                let contract_address = Address::from_slice(identity);
+                let (_eloop, transport) = web3::transports::Http::new(&self.config.ethereum_network)?;
+                let web3 = web3::Web3::new(transport);
+                let contract = Contract::from_json(web3.eth(), contract_address, &IDENTITY_ABI)?;
 
                 let privilege_level: U256 = contract
                     .query(
                         "privileges",
-                        verified.from.to_string(),
+                        (verified.from.to_string(),),
                         None,
                         Options::default(),
                         None,
@@ -225,7 +227,7 @@ impl Adapter for EthereumAdapter {
                 }
                 Session {
                     era: verified.payload.era,
-                    uid: ValidatorId::try_from(identity)?,
+                    uid: identity.into(),
                 }
             }
             None => Session {
@@ -293,8 +295,12 @@ pub struct Payload {
     pub id: String,
     pub era: i64,
     pub address: String,
-    #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub identity: Option<String>,
+    #[serde(
+        default,
+        skip_serializing_if = "Option::is_none",
+        with = "SerHexOpt::<StrictPfx>"
+    )]
+    pub identity: Option<[u8; 20]>,
 }
 
 #[derive(Clone, Debug)]

adapter/src/lib.rs

@@ -109,9 +109,9 @@ impl TryFrom<&Channel> for EthereumChannel {
 
 impl EthereumChannel {
     pub fn new(
-        creator: &[u8; 20],    // 0x prefixed using string helps check if valid eth address
-        token_addr: &[u8; 20], // 0x prefixed using string helps check if valid eth address
-        token_amount: &str,    // big num string
+        creator: &[u8; 20],
+        token_addr: &[u8; 20],
+        token_amount: &str, // big num string
         valid_until: DateTime<Utc>,
         validators: &[ValidatorId],
         spec: &[u8; 32],
@@ -174,15 +174,6 @@ impl EthereumChannel {
     }
 
     pub fn to_solidity_tuple(&self) -> Token {
-        // let spec_h256 = hex::decode(&self.spec).expect("should deserialize spec");
-        // let creator = hex::decode(&self.creator[2..]).expect("should deserialize creator");
-        // let token_addr = hex::decode(&self.token_addr[2..]).expect("should deserialize token addr");
-        // let token_amount = U256::from_dec_str(&self.token_amount).expect("should deserialize token amount");
-        // let valid_until =  U256::from_dec_str(&self.valid_until).expect("should deserialize valid until");
-
-        // let validator1 =  hex::decode("2bdeafae53940669daa6f519373f686c1f3d3393").expect("should deserialize v1");
-        // let validator2 =  hex::decode("6704Fbfcd5Ef766B287262fA2281C105d57246a6").expect("should deserialize v2");
-
         Token::Tuple(vec![
             Token::Address(self.creator.to_owned()),
             Token::Address(self.token_addr.to_owned()),
@@ -229,7 +220,7 @@ fn encode_params(params: &[(ParamType, &str)], lenient: bool) -> Result<Vec<u8>,
             }
         })
         .collect::<Result<Vec<_>, _>>()?;
-        
+
     Ok(encode(&tokens).to_vec())
 }
 

primitives/src/validator.rs

@@ -23,13 +23,10 @@ impl ValidatorId {
         &self.0
     }
 
-    pub fn copy(&self) -> &[u8] {
-        &self.0
-    }
-
     pub fn to_hex_non_prefix_string(&self) -> String {
         hex::encode(self.0)
     }
+
     pub fn to_hex_checksummed_string(&self) -> String {
         eth_checksum::checksum(&format!("0x{}", hex::encode(self.0)))
     }
@@ -41,6 +38,12 @@ impl AsRef<[u8]> for ValidatorId {
     }
 }
 
+impl From<&[u8; 20]> for ValidatorId {
+    fn from(bytes: &[u8; 20]) -> Self {
+        Self(*bytes)
+    }
+}
+
 impl TryFrom<&str> for ValidatorId {
     type Error = DomainError;
     fn try_from(value: &str) -> Result<Self, Self::Error> {