Index scheduled transfer events.

backend-rust/migrations/0003_release_schedule.down.sql

@@ -0,0 +1,4 @@
+-- Down migration script for removing the scheduled release table.
+
+-- Drop the scheduled_releases table.
+DROP TABLE IF EXISTS scheduled_releases;

backend-rust/migrations/0003_release_schedule.up.sql

@@ -0,0 +1,31 @@
+-- Migration script for adding the scheduled release table.
+
+-- Every scheduled release on chain.
+CREATE TABLE scheduled_releases (
+    -- An index/id for this scheduled release (row number).
+    index
+        BIGINT GENERATED ALWAYS AS IDENTITY
+        PRIMARY KEY,
+    -- The index of the transaction creating the scheduled transfer.
+    transaction_index
+        BIGINT
+        NOT NULL
+        REFERENCES transactions,
+    -- The account receiving the scheduled transfer.
+    account_index
+        BIGINT
+        NOT NULL
+        REFERENCES accounts,
+    -- The scheduled release time.
+    release_time
+        TIMESTAMPTZ
+        NOT NULL,
+    -- The amount locked in the scheduled release.
+    amount
+        BIGINT
+        NOT NULL
+);
+
+-- We typically want to find all scheduled releases for a specific account after a certain time.
+-- This index is useful for that.
+CREATE INDEX scheduled_releases_idx ON scheduled_releases (account_index, release_time);

backend-rust/src/graphql_api.rs

@@ -3873,8 +3873,8 @@ fn decode_value_with_schema(
     schema_name: SmartContractSchemaNames,
 ) -> String {
     let Some(schema) = opt_schema else {
-        // Note: There could be something better displayed than this string if no schema is
-        // available for decoding at the frontend long-term.
+        // Note: There could be something better displayed than this string if no schema
+        // is available for decoding at the frontend long-term.
         return format!(
             "No embedded {} schema in smart contract available for decoding",
             schema_name.kind()

backend-rust/src/indexer.rs

@@ -9,7 +9,7 @@ use anyhow::Context;
 use chrono::{DateTime, Utc};
 use concordium_rust_sdk::{
     base::{contracts_common::to_bytes, smart_contracts::WasmVersion},
-    common::types::Amount,
+    common::types::{Amount, Timestamp},
     indexer::{async_trait, Indexer, ProcessEvent, TraverseConfig, TraverseError},
     smart_contracts::engine::utils::{get_embedded_schema_v0, get_embedded_schema_v1},
     types::{
@@ -1048,6 +1048,8 @@ enum PreparedEvent {
     ContractInitialized(PreparedContractInitialized),
     /// Contract got updated.
     ContractUpdate(Vec<PreparedContractUpdate>),
+    /// A scheduled transfer got executed.
+    ScheduledTransfer(PreparedScheduledReleases),
     /// No changes in the database was caused by this event.
     NoOperation,
 }
@@ -1186,12 +1188,18 @@ impl PreparedEvent {
                 AccountTransactionEffects::TransferredWithSchedule {
                     to,
                     amount,
-                } => None,
+                } => Some(PreparedEvent::ScheduledTransfer(PreparedScheduledReleases::prepare(
+                    to.to_string(),
+                    amount,
+                )?)),
                 AccountTransactionEffects::TransferredWithScheduleAndMemo {
                     to,
                     amount,
                     memo,
-                } => None,
+                } => Some(PreparedEvent::ScheduledTransfer(PreparedScheduledReleases::prepare(
+                    to.to_string(),
+                    amount,
+                )?)),
                 AccountTransactionEffects::CredentialKeysUpdated {
                     cred_id,
                 } => None,
@@ -1237,6 +1245,7 @@ impl PreparedEvent {
                 }
                 Ok(())
             }
+            PreparedEvent::ScheduledTransfer(event) => event.save(tx, tx_idx).await,
             PreparedEvent::NoOperation => Ok(()),
         }
     }
@@ -1729,3 +1738,56 @@ impl PreparedContractUpdate {
         Ok(())
     }
 }
+
+struct PreparedScheduledReleases {
+    account_address: String,
+    release_times:   Vec<DateTime<Utc>>,
+    amounts:         Vec<i64>,
+}
+
+impl PreparedScheduledReleases {
+    fn prepare(to: String, scheduled_releases: &[(Timestamp, Amount)]) -> anyhow::Result<Self> {
+        let capacity = scheduled_releases.len();
+        let mut release_times: Vec<DateTime<Utc>> = Vec::with_capacity(capacity);
+        let mut amounts: Vec<i64> = Vec::with_capacity(capacity);
+        for (timestamp, amount) in scheduled_releases.iter() {
+            release_times.push(DateTime::<Utc>::try_from(*timestamp)?);
+            amounts.push(i64::try_from(amount.micro_ccd())?);
+        }
+
+        Ok(Self {
+            account_address: to,
+            release_times,
+            amounts,
+        })
+    }
+
+    async fn save(
+        &self,
+        tx: &mut sqlx::Transaction<'static, sqlx::Postgres>,
+        transaction_index: i64,
+    ) -> anyhow::Result<()> {
+        sqlx::query!(
+            "INSERT INTO scheduled_releases (
+                transaction_index,
+                account_index,
+                release_time,
+                amount
+            )
+            SELECT
+                $1,
+                (SELECT index FROM accounts WHERE address = $2),
+                UNNEST($3::TIMESTAMPTZ[]),
+                UNNEST($4::BIGINT[])
+            ",
+            transaction_index,
+            self.account_address,
+            &self.release_times,
+            &self.amounts
+        )
+        .execute(tx.as_mut())
+        .await?;
+        Ok(())
+    }
+    // fn prepare()
+}