fix comments

Author: OBorce

api-server/CHANGELOG.md

@@ -8,6 +8,7 @@ The format is loosely based on [Keep a Changelog](https://keepachangelog.com/en/
 
 ### Added
 - New endpoint was added: `/v2/transaction/{id}/output/{idx}`.
+- New endpoint was added: `/v2/token/{id}/transactions` will return all transactions related to a token
 
 ### Changed
 - `/v2/token/ticker/{ticker}` will now return all tokens whose ticker has the specified `{ticker}`

api-server/api-server-common/src/storage/impls/in_memory/mod.rs

@@ -48,7 +48,7 @@ struct ApiServerInMemoryStorage {
     address_balance_table: BTreeMap<String, BTreeMap<CoinOrTokenId, BTreeMap<BlockHeight, Amount>>>,
     address_locked_balance_table: BTreeMap<String, BTreeMap<(CoinOrTokenId, BlockHeight), Amount>>,
     address_transactions_table: BTreeMap<String, BTreeMap<BlockHeight, Vec<Id<Transaction>>>>,
-    token_transactions_table: BTreeMap<TokenId, BTreeMap<BlockHeight, Vec<TokenTransaction>>>,
+    token_transactions_table: BTreeMap<TokenId, BTreeMap<BlockHeight, BTreeSet<TokenTransaction>>>,
     delegation_table: BTreeMap<DelegationId, BTreeMap<BlockHeight, Delegation>>,
     main_chain_blocks_table: BTreeMap<BlockHeight, Id<Block>>,
     pool_data_table: BTreeMap<PoolId, BTreeMap<BlockHeight, PoolDataWithExtraInfo>>,
@@ -179,7 +179,7 @@ impl ApiServerInMemoryStorage {
         &self,
         token_id: TokenId,
         len: u32,
-        global_tx_index: i64,
+        tx_global_index: u64,
     ) -> Result<Vec<TokenTransaction>, ApiServerStorageError> {
         Ok(self
             .token_transactions_table
@@ -190,7 +190,7 @@ impl ApiServerInMemoryStorage {
                     .rev()
                     .flat_map(|(_, txs)| txs.iter())
                     .cloned()
-                    .flat_map(|tx| (tx.global_tx_index < global_tx_index).then_some(tx))
+                    .flat_map(|tx| (tx.tx_global_index < tx_global_index).then_some(tx))
                     .take(len as usize)
                     .collect()
             }))
@@ -237,7 +237,7 @@ impl ApiServerInMemoryStorage {
                                 additional_info: additinal_data.clone(),
                             },
                             block_aux: *block_aux,
-                            global_tx_index: *tx_global_index,
+                            tx_global_index: *tx_global_index,
                         }
                     },
                 )
@@ -263,7 +263,7 @@ impl ApiServerInMemoryStorage {
                 TransactionWithBlockInfo {
                     tx_info: tx_info.clone(),
                     block_aux: *block_aux,
-                    global_tx_index: *tx_global_index,
+                    tx_global_index: *tx_global_index,
                 }
             })
             .collect())
@@ -985,26 +985,30 @@ impl ApiServerInMemoryStorage {
         transaction_ids: BTreeSet<Id<Transaction>>,
         block_height: BlockHeight,
     ) -> Result<(), ApiServerStorageError> {
-        let next_tx_idx = self.token_transactions_table.get(&token_id).map_or(1, |tx| {
-            tx.values()
-                .last()
-                .expect("not empty")
-                .last()
-                .expect("not empty")
-                .global_tx_index
-                + 1
-        });
-        self.token_transactions_table.entry(token_id).or_default().insert(
-            block_height,
-            transaction_ids
-                .into_iter()
-                .enumerate()
-                .map(|(idx, tx_id)| TokenTransaction {
-                    global_tx_index: next_tx_idx + idx as i64,
+        if transaction_ids.is_empty() {
+            return Ok(());
+        }
+
+        let next_tx_idx = self
+            .token_transactions_table
+            .values()
+            .flat_map(|by_height| by_height.values())
+            .flat_map(|tx_set| tx_set.iter())
+            .map(|tx| tx.tx_global_index + 1)
+            .max()
+            .unwrap_or(0);
+
+        self.token_transactions_table
+            .entry(token_id)
+            .or_default()
+            .entry(block_height)
+            .or_default()
+            .extend(
+                transaction_ids.into_iter().enumerate().map(|(idx, tx_id)| TokenTransaction {
+                    tx_global_index: next_tx_idx + idx as u64,
                     tx_id,
-                })
-                .collect(),
-        );
+                }),
+            );
 
         Ok(())
     }

api-server/api-server-common/src/storage/impls/in_memory/transactional/read.rs

@@ -72,9 +72,9 @@ impl ApiServerStorageRead for ApiServerInMemoryStorageTransactionalRo<'_> {
         &self,
         token_id: TokenId,
         len: u32,
-        global_tx_index: i64,
+        tx_global_index: u64,
     ) -> Result<Vec<TokenTransaction>, ApiServerStorageError> {
-        self.transaction.get_token_transactions(token_id, len, global_tx_index)
+        self.transaction.get_token_transactions(token_id, len, tx_global_index)
     }
 
     async fn get_block(

api-server/api-server-common/src/storage/impls/in_memory/transactional/write.rs

@@ -352,9 +352,9 @@ impl ApiServerStorageRead for ApiServerInMemoryStorageTransactionalRw<'_> {
         &self,
         token_id: TokenId,
         len: u32,
-        global_tx_index: i64,
+        tx_global_index: u64,
     ) -> Result<Vec<TokenTransaction>, ApiServerStorageError> {
-        self.transaction.get_token_transactions(token_id, len, global_tx_index)
+        self.transaction.get_token_transactions(token_id, len, tx_global_index)
     }
 
     async fn get_latest_blocktimestamps(

api-server/api-server-common/src/storage/impls/mod.rs

@@ -13,7 +13,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-pub const CURRENT_STORAGE_VERSION: u32 = 23;
+pub const CURRENT_STORAGE_VERSION: u32 = 24;
 
 pub mod in_memory;
 pub mod postgres;

api-server/api-server-common/src/storage/impls/postgres/queries.rs

@@ -83,11 +83,13 @@ impl<'a, 'b> QueryFromConnection<'a, 'b> {
             .map_err(|_| ApiServerStorageError::TimestampTooHigh(block_timestamp))
     }
 
-    fn tx_global_index_to_postgres_friendly(tx_global_index: u64) -> i64 {
+    fn tx_global_index_to_postgres_friendly(
+        tx_global_index: u64,
+    ) -> Result<i64, ApiServerStorageError> {
         // Postgres doesn't like u64, so we have to convert it to i64
         tx_global_index
             .try_into()
-            .unwrap_or_else(|e| panic!("Invalid tx global index: {e}"))
+            .map_err(|_| ApiServerStorageError::TxGlobalIndexTooHigh(tx_global_index))
     }
 
     pub async fn is_initialized(&mut self) -> Result<bool, ApiServerStorageError> {
@@ -499,28 +501,29 @@ impl<'a, 'b> QueryFromConnection<'a, 'b> {
         &self,
         token_id: TokenId,
         len: u32,
-        global_tx_index: i64,
+        tx_global_index: u64,
     ) -> Result<Vec<TokenTransaction>, ApiServerStorageError> {
+        let tx_global_index = Self::tx_global_index_to_postgres_friendly(tx_global_index)?;
         let len = len as i64;
         let rows = self
             .tx
             .query(
                 r#"
-                    SELECT global_tx_index, transaction_id
+                    SELECT tx_global_index, transaction_id
                     FROM ml.token_transactions
-                    WHERE token_id = $1 AND global_tx_index < $2
-                    ORDER BY global_tx_index DESC
+                    WHERE token_id = $1 AND tx_global_index < $2
+                    ORDER BY tx_global_index DESC
                     LIMIT $3;
                 "#,
-                &[&token_id.encode(), &global_tx_index, &len],
+                &[&token_id.encode(), &tx_global_index, &len],
             )
             .await
             .map_err(|e| ApiServerStorageError::LowLevelStorageError(e.to_string()))?;
 
         let mut transactions = Vec::with_capacity(rows.len());
 
         for row in &rows {
-            let global_tx_index: i64 = row.get(0);
+            let tx_global_index: i64 = row.get(0);
             let tx_id: Vec<u8> = row.get(1);
             let tx_id = Id::<Transaction>::decode_all(&mut tx_id.as_slice()).map_err(|e| {
                 ApiServerStorageError::DeserializationError(format!(
@@ -530,7 +533,7 @@ impl<'a, 'b> QueryFromConnection<'a, 'b> {
             })?;
 
             transactions.push(TokenTransaction {
-                global_tx_index,
+                tx_global_index: tx_global_index as u64,
                 tx_id,
             });
         }
@@ -763,7 +766,7 @@ impl<'a, 'b> QueryFromConnection<'a, 'b> {
         self.just_execute(
             "CREATE TABLE ml.transactions (
                     transaction_id bytea PRIMARY KEY,
-                    global_tx_index bigint NOT NULL,
+                    tx_global_index bigint NOT NULL,
                     owning_block_id bytea NOT NULL REFERENCES ml.blocks(block_id),
                     transaction_data bytea NOT NULL
                 );", // block_id can be null if the transaction is not in the main chain
@@ -820,7 +823,7 @@ impl<'a, 'b> QueryFromConnection<'a, 'b> {
 
         self.just_execute(
             "CREATE TABLE ml.token_transactions (
-                    global_tx_index bigint PRIMARY KEY GENERATED ALWAYS AS IDENTITY,
+                    tx_global_index bigint PRIMARY KEY GENERATED ALWAYS AS IDENTITY (START WITH 0 MINVALUE 0),
                     token_id bytea NOT NULL,
                     block_height bigint NOT NULL,
                     transaction_id bytea NOT NULL,
@@ -829,7 +832,7 @@ impl<'a, 'b> QueryFromConnection<'a, 'b> {
         )
         .await?;
 
-        self.just_execute("CREATE INDEX token_transactions_global_tx_index ON ml.token_transactions (token_id, global_tx_index DESC);")
+        self.just_execute("CREATE INDEX token_transactions_global_tx_index ON ml.token_transactions (token_id, tx_global_index DESC);")
             .await?;
 
         self.just_execute(
@@ -1903,12 +1906,12 @@ impl<'a, 'b> QueryFromConnection<'a, 'b> {
                 SELECT
                     t.transaction_data,
                     b.aux_data,
-                    t.global_tx_index
+                    t.tx_global_index
                 FROM
                     ml.transactions t
                 INNER JOIN
                     ml.block_aux_data b ON t.owning_block_id = b.block_id
-                ORDER BY t.global_tx_index DESC
+                ORDER BY t.tx_global_index DESC
                 OFFSET $1
                 LIMIT $2;
                 "#,
@@ -1921,7 +1924,7 @@ impl<'a, 'b> QueryFromConnection<'a, 'b> {
             .map(|data| {
                 let transaction_data: Vec<u8> = data.get(0);
                 let block_data: Vec<u8> = data.get(1);
-                let global_tx_index: i64 = data.get(2);
+                let tx_global_index: i64 = data.get(2);
 
                 let block_aux =
                     BlockAuxData::decode_all(&mut block_data.as_slice()).map_err(|e| {
@@ -1941,7 +1944,7 @@ impl<'a, 'b> QueryFromConnection<'a, 'b> {
                 Ok(TransactionWithBlockInfo {
                     tx_info,
                     block_aux,
-                    global_tx_index: global_tx_index as u64,
+                    tx_global_index: tx_global_index as u64,
                 })
             })
             .collect()
@@ -1950,24 +1953,24 @@ impl<'a, 'b> QueryFromConnection<'a, 'b> {
     pub async fn get_transactions_with_block_before_tx_global_index(
         &self,
         len: u32,
-        global_tx_index: u64,
+        tx_global_index: u64,
     ) -> Result<Vec<TransactionWithBlockInfo>, ApiServerStorageError> {
         let len = len as i64;
-        let tx_global_index = Self::tx_global_index_to_postgres_friendly(global_tx_index);
+        let tx_global_index = Self::tx_global_index_to_postgres_friendly(tx_global_index)?;
         let rows = self
             .tx
             .query(
                 r#"
                 SELECT
                     t.transaction_data,
                     b.aux_data,
-                    t.global_tx_index
+                    t.tx_global_index
                 FROM
                     ml.transactions t
                 INNER JOIN
                     ml.block_aux_data b ON t.owning_block_id = b.block_id
-                WHERE t.global_tx_index < $1
-                ORDER BY t.global_tx_index DESC
+                WHERE t.tx_global_index < $1
+                ORDER BY t.tx_global_index DESC
                 LIMIT $2;
                 "#,
                 &[&tx_global_index, &len],
@@ -1979,7 +1982,7 @@ impl<'a, 'b> QueryFromConnection<'a, 'b> {
             .map(|data| {
                 let transaction_data: Vec<u8> = data.get(0);
                 let block_data: Vec<u8> = data.get(1);
-                let global_tx_index: i64 = data.get(2);
+                let tx_global_index: i64 = data.get(2);
 
                 let block_aux =
                     BlockAuxData::decode_all(&mut block_data.as_slice()).map_err(|e| {
@@ -1999,7 +2002,7 @@ impl<'a, 'b> QueryFromConnection<'a, 'b> {
                 Ok(TransactionWithBlockInfo {
                     tx_info,
                     block_aux,
-                    global_tx_index: global_tx_index as u64,
+                    tx_global_index: tx_global_index as u64,
                 })
             })
             .collect()
@@ -2013,7 +2016,7 @@ impl<'a, 'b> QueryFromConnection<'a, 'b> {
             .query_one(
                 r#"
                 SELECT
-                    MAX(t.global_tx_index)
+                    MAX(t.tx_global_index)
                 FROM
                     ml.transactions t;
                 "#,
@@ -2030,7 +2033,7 @@ impl<'a, 'b> QueryFromConnection<'a, 'b> {
     pub async fn set_transaction(
         &mut self,
         transaction_id: Id<Transaction>,
-        global_tx_index: u64,
+        tx_global_index: u64,
         owning_block: Id<Block>,
         transaction: &TransactionInfo,
     ) -> Result<(), ApiServerStorageError> {
@@ -2039,13 +2042,13 @@ impl<'a, 'b> QueryFromConnection<'a, 'b> {
             transaction_id,
             owning_block
         );
-        let global_tx_index = Self::tx_global_index_to_postgres_friendly(global_tx_index);
+        let tx_global_index = Self::tx_global_index_to_postgres_friendly(tx_global_index)?;
 
         self.tx.execute(
-                "INSERT INTO ml.transactions (transaction_id, owning_block_id, transaction_data, global_tx_index) VALUES ($1, $2, $3, $4)
+                "INSERT INTO ml.transactions (transaction_id, owning_block_id, transaction_data, tx_global_index) VALUES ($1, $2, $3, $4)
                     ON CONFLICT (transaction_id) DO UPDATE
-                    SET owning_block_id = $2, transaction_data = $3, global_tx_index = $4;",
-                &[&transaction_id.encode(), &owning_block.encode(), &transaction.encode(), &global_tx_index]
+                    SET owning_block_id = $2, transaction_data = $3, tx_global_index = $4;",
+                &[&transaction_id.encode(), &owning_block.encode(), &transaction.encode(), &tx_global_index]
             ).await
             .map_err(|e| ApiServerStorageError::LowLevelStorageError(e.to_string()))?;
 

api-server/api-server-common/src/storage/impls/postgres/transactional/read.rs

@@ -98,10 +98,10 @@ impl ApiServerStorageRead for ApiServerPostgresTransactionalRo<'_> {
         &self,
         token_id: TokenId,
         len: u32,
-        global_tx_index: i64,
+        tx_global_index: u64,
     ) -> Result<Vec<TokenTransaction>, ApiServerStorageError> {
         let conn = QueryFromConnection::new(self.connection.as_ref().expect(CONN_ERR));
-        let res = conn.get_token_transactions(token_id, len, global_tx_index).await?;
+        let res = conn.get_token_transactions(token_id, len, tx_global_index).await?;
 
         Ok(res)
     }

api-server/api-server-common/src/storage/impls/postgres/transactional/write.rs

@@ -461,10 +461,10 @@ impl ApiServerStorageRead for ApiServerPostgresTransactionalRw<'_> {
         &self,
         token_id: TokenId,
         len: u32,
-        global_tx_index: i64,
+        tx_global_index: u64,
     ) -> Result<Vec<TokenTransaction>, ApiServerStorageError> {
         let conn = QueryFromConnection::new(self.connection.as_ref().expect(CONN_ERR));
-        let res = conn.get_token_transactions(token_id, len, global_tx_index).await?;
+        let res = conn.get_token_transactions(token_id, len, tx_global_index).await?;
 
         Ok(res)
     }