Add transaction_assets

Settings.toml

@@ -88,7 +88,7 @@ url = "https://bsc-dataseed1.bnbchain.org"
 url = "https://polygon.llamarpc.com"
 
 [chains.optimism]
-url = "https://optimism.llamarpc.com"
+url = "https://mainnet.optimism.io"
 
 [chains.arbitrum]
 url = "https://arbitrum.llamarpc.com"

parser/src/parser.rs

@@ -260,8 +260,6 @@ impl Parser {
             .map(storage::models::Transaction::from_primitive)
             .collect::<Vec<storage::models::Transaction>>();
 
-        let result = self.database.add_transactions(transactions.clone())?;
-
         let transaction_addresses = primitive_transactions
             .clone()
             .into_iter()
@@ -277,10 +275,28 @@ impl Parser {
             })
             .filter(|x| !x.address.is_empty())
             .collect::<Vec<storage::models::TransactionAddresses>>();
-        let _ = self
-            .database
-            .add_transactions_addresses(transaction_addresses.clone())?;
 
-        Ok(result)
+        let transactions_assets = primitive_transactions
+            .clone()
+            .into_iter()
+            .flat_map(|transaction| {
+                transaction
+                    .asset_ids()
+                    .into_iter()
+                    .map(|asset_id| storage::models::TransactionAssets {
+                        transaction_id: transaction.id.clone(),
+                        asset_id,
+                    })
+                    .collect::<Vec<storage::models::TransactionAssets>>()
+            })
+            .collect::<Vec<storage::models::TransactionAssets>>();
+
+        let _ = self.database.add_transactions(
+            transactions.clone(),
+            transaction_addresses,
+            transactions_assets,
+        )?;
+
+        Ok(transactions.len())
     }
 }

primitives/src/transaction.rs

@@ -1,7 +1,7 @@
 use crate::{
     asset_id::AssetId, transaction_direction::TransactionDirection,
     transaction_state::TransactionState, transaction_type::TransactionType,
-    transaction_utxo::TransactionInput, Chain,
+    transaction_utxo::TransactionInput, Chain, TransactionSwapMetadata,
 };
 
 use chrono::offset::Utc;
@@ -271,4 +271,20 @@ impl Transaction {
             .map(|x| x.value.parse::<i64>().unwrap())
             .sum::<i64>()
     }
+
+    pub fn asset_ids(&self) -> Vec<String> {
+        match self.transaction_type {
+            TransactionType::Transfer => vec![self.asset_id.clone().to_string()],
+            TransactionType::Swap => {
+                let metadata: TransactionSwapMetadata =
+                    serde_json::from_value(self.metadata.clone()).unwrap();
+
+                vec![
+                    metadata.from_asset.to_string(),
+                    metadata.to_asset.to_string(),
+                ]
+            }
+            TransactionType::TokenApproval => vec![self.asset_id.clone().to_string()],
+        }
+    }
 }

storage/src/database.rs

@@ -2,6 +2,7 @@ use crate::models::asset::AssetDetail;
 use crate::models::*;
 use crate::schema::{devices, transactions_addresses};
 use chrono::{Duration, NaiveDateTime, Utc};
+use diesel::associations::HasTable;
 use diesel::pg::PgConnection;
 use diesel::prelude::*;
 use diesel::{upsert::excluded, Connection};
@@ -357,35 +358,52 @@ impl DatabaseClient {
 
     pub fn add_transactions(
         &mut self,
-        _transactions: Vec<Transaction>,
-    ) -> Result<usize, diesel::result::Error> {
-        use crate::schema::transactions::dsl::*;
-        diesel::insert_into(transactions)
-            .values(&_transactions)
-            .on_conflict((chain, hash))
-            .do_update()
-            .set((
-                block_number.eq(excluded(block_number)),
-                sequence.eq(excluded(sequence)),
-                fee.eq(excluded(fee)),
-                fee_asset_id.eq(excluded(fee_asset_id)),
-                memo.eq(excluded(memo)),
-                updated_at.eq(excluded(updated_at)),
-            ))
-            .execute(&mut self.connection)
-    }
-
-    // only used for utxo chains
-    pub fn add_transactions_addresses(
-        &mut self,
-        values: Vec<TransactionAddresses>,
-    ) -> Result<usize, diesel::result::Error> {
-        use crate::schema::transactions_addresses::dsl::*;
-        diesel::insert_into(transactions_addresses)
-            .values(&values)
-            .on_conflict((transaction_id, address))
-            .do_nothing()
-            .execute(&mut self.connection)
+        transactions_values: Vec<Transaction>,
+        addresses_values: Vec<TransactionAddresses>,
+        assets_values: Vec<TransactionAssets>,
+    ) -> Result<bool, diesel::result::Error> {
+        return self
+            .connection
+            .build_transaction()
+            .read_write()
+            .run::<_, diesel::result::Error, _>(|conn: &mut PgConnection| {
+                use crate::schema::transactions::dsl::*;
+                let _ = diesel::insert_into(transactions::table())
+                    .values(transactions_values)
+                    .on_conflict((chain, hash))
+                    .do_update()
+                    .set((
+                        block_number.eq(excluded(block_number)),
+                        sequence.eq(excluded(sequence)),
+                        fee.eq(excluded(fee)),
+                        fee_asset_id.eq(excluded(fee_asset_id)),
+                        memo.eq(excluded(memo)),
+                        updated_at.eq(excluded(updated_at)),
+                    ))
+                    .execute(conn);
+
+                use crate::schema::transactions_addresses::dsl::*;
+                let _ = diesel::insert_into(transactions_addresses::table())
+                    .values(&addresses_values)
+                    .on_conflict((
+                        super::schema::transactions_addresses::transaction_id,
+                        super::schema::transactions_addresses::address,
+                    ))
+                    .do_nothing()
+                    .execute(conn);
+
+                use crate::schema::transactions_assets::dsl::*;
+                let _ = diesel::insert_into(transactions_assets::table())
+                    .values(&assets_values)
+                    .on_conflict((
+                        super::schema::transactions_assets::transaction_id,
+                        super::schema::transactions_assets::asset_id,
+                    ))
+                    .do_nothing()
+                    .execute(conn);
+
+                Ok(true)
+            });
     }
 
     pub fn get_transactions_by_device_id(

storage/src/migrations/2023-12-25-214023_transactions_assets/down.sql

@@ -0,0 +1 @@
+drop table transactions_assets;

storage/src/migrations/2023-12-25-214023_transactions_assets/up.sql

@@ -0,0 +1,6 @@
+CREATE TABLE transactions_assets (
+    id SERIAL PRIMARY KEY,
+    transaction_id VARCHAR(256) NOT NULL REFERENCES transactions (id) ON DELETE CASCADE ,
+    asset_id VARCHAR(256) NOT NULL REFERENCES assets (id) ON DELETE CASCADE,
+    UNIQUE(transaction_id, asset_id)
+);

storage/src/models/mod.rs

@@ -13,6 +13,7 @@ pub mod subscription;
 pub mod tokenlist;
 pub mod transaction;
 pub mod transaction_addresses;
+pub mod transaction_assets;
 pub mod version;
 
 pub use self::asset::Asset;
@@ -31,4 +32,5 @@ pub use self::subscription::Subscription;
 pub use self::tokenlist::TokenList;
 pub use self::transaction::Transaction;
 pub use self::transaction_addresses::TransactionAddresses;
+pub use self::transaction_assets::TransactionAssets;
 pub use self::version::Version;

storage/src/models/transaction.rs

@@ -26,7 +26,7 @@ pub struct Transaction {
     pub asset_id: String,
     pub value: Option<String>,
     pub fee: Option<String>,
-    pub fee_asset_id: Option<String>,
+    pub fee_asset_id: String,
     pub block_number: i32,
     pub sequence: Option<i32>,
     pub from_address: Option<String>,
@@ -49,7 +49,7 @@ impl Transaction {
             asset_id: transaction.asset_id.to_string(),
             value: transaction.value.into(),
             fee: transaction.fee.into(),
-            fee_asset_id: transaction.fee_asset_id.to_string().into(),
+            fee_asset_id: transaction.fee_asset_id.to_string(),
             block_number: transaction.block_number.parse::<i32>().unwrap_or_default(),
             sequence: transaction
                 .sequence
@@ -98,7 +98,7 @@ impl Transaction {
             self.block_number.to_string(),
             self.sequence.unwrap_or_default().to_string(),
             self.fee.clone().unwrap(),
-            AssetId::new(self.fee_asset_id.clone().unwrap().as_str()).unwrap(),
+            AssetId::new(self.fee_asset_id.clone().as_str()).unwrap(),
             self.value.clone().unwrap_or_default(),
             self.memo.clone(),
             direction,

storage/src/models/transaction_assets.rs

@@ -0,0 +1,10 @@
+use diesel::prelude::*;
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Queryable, Selectable, Serialize, Deserialize, Insertable, AsChangeset, Clone)]
+#[diesel(table_name = crate::schema::transactions_assets)]
+#[diesel(check_for_backend(diesel::pg::Pg))]
+pub struct TransactionAssets {
+    pub transaction_id: String,
+    pub asset_id: String,
+}

storage/src/schema.rs

@@ -240,7 +240,7 @@ diesel::table! {
         fee -> Nullable<Varchar>,
         utxo_inputs -> Nullable<Jsonb>,
         utxo_outputs -> Nullable<Jsonb>,
-        fee_asset_id -> Nullable<Varchar>,
+        fee_asset_id -> Varchar,
         block_created_at -> Timestamp,
         updated_at -> Timestamp,
         created_at -> Timestamp,
@@ -258,6 +258,16 @@ diesel::table! {
     }
 }
 
+diesel::table! {
+    transactions_assets (id) {
+        id -> Int4,
+        #[max_length = 256]
+        transaction_id -> Varchar,
+        #[max_length = 256]
+        asset_id -> Varchar,
+    }
+}
+
 diesel::table! {
     versions (id) {
         id -> Int4,
@@ -273,6 +283,8 @@ diesel::joinable!(assets_details -> assets (asset_id));
 diesel::joinable!(subscriptions -> devices (device_id));
 diesel::joinable!(swap_assets -> assets (asset_id));
 diesel::joinable!(transactions_addresses -> transactions (transaction_id));
+diesel::joinable!(transactions_assets -> assets (asset_id));
+diesel::joinable!(transactions_assets -> transactions (transaction_id));
 
 diesel::allow_tables_to_appear_in_same_query!(
     assets,
@@ -291,5 +303,6 @@ diesel::allow_tables_to_appear_in_same_query!(
     tokenlists,
     transactions,
     transactions_addresses,
+    transactions_assets,
     versions,
 );