Enhance the filter (#11)

Split `accounts` to `spends` and `receives`

src/get.rs

@@ -9,7 +9,7 @@ async fn handler(info: web::Path<AnyId>, ctx: web::Data<Context>) -> impl Respon
         AnyId::Account(account_id) => (
             false,
             Filter {
-                accounts: vec![account_id],
+                spends: vec![account_id],
                 typ: vec![Type::Deposit, Type::Withdrawal, Type::Transaction],
                 ..Default::default()
             },

utxo/src/broadcaster.rs

@@ -88,7 +88,11 @@ impl Worker for Broadcaster {
             };
 
             for (filter, sender_index) in listeners {
-                if filter.matches(&transaction.transaction, &transaction.revision) {
+                if filter.matches(
+                    &transaction.transaction,
+                    &transaction.revision,
+                    &transaction.revision_id,
+                ) {
                     if let Some(Err(TrySendError::Closed(_))) = senders
                         .get(sender_index)
                         .map(|sender| sender.try_send(transaction.clone()))

utxo/src/filter.rs

@@ -11,7 +11,9 @@ pub enum PrimaryFilter {
     /// By revision ID
     Revision(Vec<RevId>),
     /// By accounts
-    Account(Vec<AccountId>),
+    Spends(Vec<AccountId>),
+    /// By accounts
+    Receives(Vec<AccountId>),
     /// By transaction type
     Type(Vec<Type>),
     /// By transaction status
@@ -34,7 +36,9 @@ pub enum FilterableValue {
     /// Revision ID
     Revision(RevId),
     /// Account
-    Account(AccountId),
+    Spends(AccountId),
+    /// Account
+    Receives(AccountId),
     /// Status
     Status(Status),
     /// Transaction type
@@ -53,9 +57,13 @@ impl From<PrimaryFilter> for Vec<FilterableValue> {
                 .into_iter()
                 .map(FilterableValue::Revision)
                 .collect(),
-            PrimaryFilter::Account(accounts) => {
-                accounts.into_iter().map(FilterableValue::Account).collect()
+            PrimaryFilter::Spends(accounts) => {
+                accounts.into_iter().map(FilterableValue::Spends).collect()
             }
+            PrimaryFilter::Receives(accounts) => accounts
+                .into_iter()
+                .map(FilterableValue::Receives)
+                .collect(),
             PrimaryFilter::Status(statuses) => {
                 statuses.into_iter().map(FilterableValue::Status).collect()
             }
@@ -78,9 +86,12 @@ pub struct Filter {
     /// List of revisions to query
     #[serde(skip_serializing_if = "Vec::is_empty", default)]
     pub revisions: Vec<RevId>,
-    /// List of accounts to query their transactions
+    /// List of accounts spending funds to query their transactions
     #[serde(skip_serializing_if = "Vec::is_empty", default)]
-    pub accounts: Vec<AccountId>,
+    pub spends: Vec<AccountId>,
+    /// List of accounts receiving funds to query their transactions
+    #[serde(skip_serializing_if = "Vec::is_empty", default)]
+    pub receives: Vec<AccountId>,
     /// List of transaction types-kind
     #[serde(rename = "type", skip_serializing_if = "Vec::is_empty", default)]
     pub typ: Vec<Type>,
@@ -120,8 +131,10 @@ impl Filter {
             PrimaryFilter::Revision(std::mem::take(&mut self.revisions))
         } else if !self.ids.is_empty() {
             PrimaryFilter::TxId(std::mem::take(&mut self.ids))
-        } else if !self.accounts.is_empty() {
-            PrimaryFilter::Account(std::mem::take(&mut self.accounts))
+        } else if !self.spends.is_empty() {
+            PrimaryFilter::Spends(std::mem::take(&mut self.spends))
+        } else if !self.receives.is_empty() {
+            PrimaryFilter::Receives(std::mem::take(&mut self.receives))
         } else if !self.typ.is_empty() {
             PrimaryFilter::Type(std::mem::take(&mut self.typ))
         } else if !self.tags.is_empty() {
@@ -139,7 +152,8 @@ impl Filter {
     pub fn prepare(mut self) -> Self {
         self.ids.sort();
         self.revisions.sort();
-        self.accounts.sort();
+        self.spends.sort();
+        self.receives.sort();
         self.typ.sort();
         self.status.sort();
         self.tags.sort();
@@ -149,7 +163,7 @@ impl Filter {
     /// Check if the base transaction and the revision matches the current cursor filter
     ///
     /// Before this function is called, the filter needs to be prepareted with `prepare` function
-    pub fn matches(&self, base: &BaseTx, revision: &Revision) -> bool {
+    pub fn matches(&self, base: &BaseTx, revision: &Revision, revision_id: &RevId) -> bool {
         let since = self
             .since
             .map(|since| since <= base.created_at)
@@ -172,12 +186,7 @@ impl Filter {
             return false;
         }
 
-        if !self.revisions.is_empty()
-            && self
-                .revisions
-                .binary_search(&revision.rev_id().expect("vv"))
-                .is_err()
-        {
+        if !self.revisions.is_empty() && self.revisions.binary_search(&revision_id).is_err() {
             return false;
         }
 
@@ -185,6 +194,34 @@ impl Filter {
             return false;
         }
 
+        let accounts = base.accounts();
+
+        if !self.spends.is_empty() {
+            let mut found = false;
+            for account in accounts.spends.iter() {
+                if self.spends.binary_search(account).is_ok() {
+                    found = true;
+                    break;
+                }
+            }
+            if !found {
+                return false;
+            }
+        }
+
+        if !self.receives.is_empty() {
+            let mut found = false;
+            for account in accounts.receives.iter() {
+                if self.receives.binary_search(account).is_ok() {
+                    found = true;
+                    break;
+                }
+            }
+            if !found {
+                return false;
+            }
+        }
+
         if !self.tags.is_empty() {
             let mut found = false;
             for tag in revision.tags.iter() {
@@ -207,9 +244,15 @@ impl Filter {
         self
     }
 
-    /// Adds a given tag to the filter
-    pub fn account(mut self, account: AccountId) -> Self {
-        self.accounts.push(account);
+    /// Adds a spending account to the filter
+    pub fn spends(mut self, account: AccountId) -> Self {
+        self.spends.push(account);
+        self
+    }
+
+    /// Adds a receiving account to the filter
+    pub fn receives(mut self, account: AccountId) -> Self {
+        self.receives.push(account);
         self
     }
 
@@ -256,7 +299,7 @@ impl From<RevId> for Filter {
 impl From<AccountId> for Filter {
     fn from(value: AccountId) -> Self {
         Filter {
-            accounts: vec![value],
+            spends: vec![value],
             ..Default::default()
         }
     }
@@ -329,8 +372,16 @@ mod test {
             ..Default::default()
         }
         .prepare();
-        assert!(!filter_until.matches(&current.transaction, &current.revision));
-        assert!(filter_since.matches(&current.transaction, &current.revision));
+        assert!(!filter_until.matches(
+            &current.transaction,
+            &current.revision,
+            &current.revision_id
+        ));
+        assert!(filter_since.matches(
+            &current.transaction,
+            &current.revision,
+            &current.revision_id
+        ));
     }
 
     #[test]
@@ -356,7 +407,15 @@ mod test {
             ..Default::default()
         }
         .prepare();
-        assert!(!filter_foo.matches(&current.transaction, &current.revision));
-        assert!(filter_settled.matches(&current.transaction, &current.revision));
+        assert!(!filter_foo.matches(
+            &current.transaction,
+            &current.revision,
+            &current.revision_id
+        ));
+        assert!(filter_settled.matches(
+            &current.transaction,
+            &current.revision,
+            &current.revision_id
+        ));
     }
 }

utxo/src/id/mod.rs

@@ -72,6 +72,36 @@ impl<'de, const MAX_LENGTH: usize> de::Deserialize<'de> for MaxLengthString<MAX_
 
 /// The AccountId data type
 pub type AccountId = MaxLengthString<64>;
+
+/// Accounts
+pub struct Accounts {
+    /// Spending accounts
+    pub spends: Vec<AccountId>,
+    /// Creating accounts
+    pub receives: Vec<AccountId>,
+}
+
+impl From<&BaseTx> for Accounts {
+    fn from(tx: &BaseTx) -> Self {
+        let mut spends = tx.spends.iter().map(|x| x.from.clone()).collect::<Vec<_>>();
+        let mut receives = tx.creates.iter().map(|x| x.to.clone()).collect::<Vec<_>>();
+
+        receives.sort();
+        receives.dedup();
+
+        spends.sort();
+        spends.dedup();
+
+        Self { spends, receives }
+    }
+}
+
+impl From<&Transaction> for Accounts {
+    fn from(tx: &Transaction) -> Self {
+        (&tx.transaction).into()
+    }
+}
+
 crate::BinaryId!(TxId, "tx");
 crate::BinaryId!(RevId, "rev");
 
@@ -128,4 +158,6 @@ mod binary;
 mod error;
 mod payment;
 
+use crate::{BaseTx, Transaction};
+
 pub use self::{error::Error, payment::PaymentId};

utxo/src/ledger.rs

@@ -3,7 +3,7 @@ use crate::{
     broadcaster::Broadcaster,
     config::Config,
     status::{InternalStatus, StatusManager},
-    storage::{Batch, ReceivedPaymentStatus, Storage},
+    storage::{AccountTransactionType, Batch, ReceivedPaymentStatus, Storage},
     transaction::Error as TxError,
     transaction::Type,
     worker::WorkerManager,
@@ -215,15 +215,30 @@ where
             )
             .await?;
 
-        for account in transaction.accounts() {
+        let accounts = transaction.accounts();
+
+        for account in accounts.spends {
             batch
                 .relate_account_to_transaction(
+                    AccountTransactionType::Spends,
                     &transaction.revision.transaction_id,
                     &account,
                     transaction.typ,
                 )
                 .await?;
         }
+
+        for account in accounts.receives {
+            batch
+                .relate_account_to_transaction(
+                    AccountTransactionType::Receives,
+                    &transaction.revision.transaction_id,
+                    &account,
+                    transaction.typ,
+                )
+                .await?;
+        }
+
         batch
             .store_base_transaction(
                 &transaction.revision.transaction_id,

utxo/src/storage/cache/batch.rs

@@ -1,7 +1,7 @@
 use super::Storage;
 use crate::{
     payment::PaymentTo,
-    storage::{Batch, Error, ReceivedPaymentStatus},
+    storage::{AccountTransactionType, Batch, Error, ReceivedPaymentStatus},
     AccountId, BaseTx, PaymentId, RevId, Revision, Tag, TxId,
 };
 use std::{collections::HashMap, marker::PhantomData, sync::Arc};
@@ -68,6 +68,7 @@ where
 
     async fn relate_account_to_transaction(
         &mut self,
+        account_type: AccountTransactionType,
         transaction_id: &TxId,
         account: &AccountId,
         typ: crate::Type,
@@ -76,7 +77,7 @@ where
             .insert(Ids::Transaction(transaction_id.clone()), ());
         self.to_invalidate.insert(Ids::Account(account.clone()), ());
         self.inner
-            .relate_account_to_transaction(transaction_id, account, typ)
+            .relate_account_to_transaction(account_type, transaction_id, account, typ)
             .await
     }
 

utxo/src/storage/cursor.rs

@@ -1,5 +1,5 @@
 //! Cursor implementation
-use crate::{BaseTx, Filter, PrimaryFilter, Revision};
+use crate::{BaseTx, Filter, PrimaryFilter, RevId, Revision};
 
 #[derive(Debug, PartialEq, Eq, Hash, Clone)]
 /// The cursor
@@ -22,7 +22,7 @@ impl From<Filter> for Cursor {
 
 impl Cursor {
     /// Check if the base transaction and the revision matches the current cursor filter
-    pub fn matches(&self, base_tx: &BaseTx, revision: &Revision) -> bool {
-        self.filter.matches(base_tx, revision)
+    pub fn matches(&self, base_tx: &BaseTx, revision: &Revision, revision_id: &RevId) -> bool {
+        self.filter.matches(base_tx, revision, revision_id)
     }
 }

utxo/src/storage/mod.rs

@@ -29,6 +29,24 @@ pub enum ReceivedPaymentStatus {
     Spent,
 }
 
+#[derive(Clone, Copy, PartialEq, Eq, Debug, Serialize)]
+/// Account-Transaction type
+pub enum AccountTransactionType {
+    /// Spends
+    Spends,
+    /// Receives
+    Receives,
+}
+
+impl ToString for AccountTransactionType {
+    fn to_string(&self) -> String {
+        match self {
+            AccountTransactionType::Spends => "spends".to_string(),
+            AccountTransactionType::Receives => "receives".to_string(),
+        }
+    }
+}
+
 /// Serializes an object to bytes using the default serialization method
 pub fn to_bytes<T>(val: &T) -> Result<Vec<u8>, Error>
 where
@@ -209,6 +227,7 @@ pub trait Batch<'a> {
     /// layer.
     async fn relate_account_to_transaction(
         &mut self,
+        account_type: AccountTransactionType,
         transaction: &TxId,
         account: &AccountId,
         typ: Type,
@@ -1087,11 +1106,21 @@ pub mod test {
             .await
             .expect("update tx");
         batch
-            .relate_account_to_transaction(&deposit.id, &account1, Type::Deposit)
+            .relate_account_to_transaction(
+                AccountTransactionType::Receives,
+                &deposit.id,
+                &account1,
+                Type::Deposit,
+            )
             .await
             .expect("relationship");
         batch
-            .relate_account_to_transaction(&deposit.id, &account2, Type::Deposit)
+            .relate_account_to_transaction(
+                AccountTransactionType::Receives,
+                &deposit.id,
+                &account2,
+                Type::Deposit,
+            )
             .await
             .expect("relationship");
 
@@ -1105,7 +1134,7 @@ pub mod test {
         assert_eq!(
             1,
             storage
-                .find(filter.clone().account(account1.clone()))
+                .find(filter.clone().receives(account1.clone()))
                 .await
                 .expect("valid tx")
                 .len()
@@ -1113,7 +1142,7 @@ pub mod test {
         assert_eq!(
             1,
             storage
-                .find(filter.clone().account(account2.clone()))
+                .find(filter.clone().receives(account2.clone()))
                 .await
                 .expect("valid tx")
                 .len()
@@ -1121,7 +1150,7 @@ pub mod test {
         assert_eq!(
             0,
             storage
-                .find(filter.account(account3.clone()))
+                .find(filter.spends(account3.clone()))
                 .await
                 .expect("valid tx")
                 .len()
@@ -1132,7 +1161,7 @@ pub mod test {
                 storage
                     .find(Filter {
                         typ: vec![Type::Withdrawal],
-                        accounts: vec![account],
+                        spends: vec![account],
                         ..Default::default()
                     })
                     .await

utxo/src/storage/sqlite/batch.rs

@@ -1,6 +1,6 @@
 use crate::{
     payment::PaymentTo,
-    storage::{self, to_bytes, Error, ReceivedPaymentStatus},
+    storage::{self, to_bytes, AccountTransactionType, Error, ReceivedPaymentStatus},
     AccountId, BaseTx, PaymentId, RevId, Revision, Tag, TxId, Type,
 };
 use sqlx::{Row, Sqlite, Transaction as SqlxTransaction};
@@ -36,16 +36,18 @@ impl<'a> storage::Batch<'a> for Batch<'a> {
 
     async fn relate_account_to_transaction(
         &mut self,
+        account_type: AccountTransactionType,
         transaction: &TxId,
         account: &AccountId,
         typ: Type,
     ) -> Result<(), Error> {
         sqlx::query(
             r#"
-            INSERT INTO "transaction_accounts" ("transaction_id", "account_id", "type")
-            VALUES (?, ?, ?)
+            INSERT INTO "transaction_accounts" ("relationship", "transaction_id", "account_id", "type")
+            VALUES (?, ?, ?, ?)
             "#,
         )
+        .bind(account_type.to_string()  )
         .bind(transaction.to_string())
         .bind(account.to_string())
         .bind::<u32>(typ.into())

utxo/src/storage/sqlite/mod.rs

@@ -1,5 +1,5 @@
 //! SQLite storage layer for Verax
-use super::{Cursor, ReceivedPaymentStatus};
+use super::{AccountTransactionType, Cursor, ReceivedPaymentStatus};
 use crate::{
     amount::AmountCents,
     storage::{Error, Storage},
@@ -30,7 +30,7 @@ async fn find_candidates<'e, 'c: 'e, E>(
     executor: E,
     cursor: &mut Cursor,
     limit: usize,
-) -> Result<Vec<(BaseTx, Revision)>, Error>
+) -> Result<Vec<(BaseTx, Revision, RevId)>, Error>
 where
     E: sqlx::Executor<'c, Database = sqlx::Sqlite>,
 {
@@ -51,7 +51,8 @@ where
                 r#"
                     SELECT
                         "bt"."blob",
-                        "b"."blob"
+                        "b"."blob",
+                        "t"."revision_id"
                     FROM
                         "transactions" as "t",
                         "base_transactions" as "bt",
@@ -85,7 +86,8 @@ where
                 r#"
                     SELECT
                         "bt"."blob",
-                        "b"."blob"
+                        "b"."blob",
+                        "b"."revision_id"
                     FROM
                         "base_transactions" as "bt",
                         "revisions" as "b"
@@ -108,12 +110,13 @@ where
             }
             query.fetch_all(executor).await
         }
-        PrimaryFilter::Account(account_ids) => {
+        PrimaryFilter::Receives(account_ids) => {
             let sql = format!(
                 r#"
                     SELECT
                         "bt"."blob",
-                        "b"."blob"
+                        "b"."blob",
+                        "b"."revision_id"
                     FROM
                         "transaction_accounts" as "ta",
                         "transactions" as "t",
@@ -121,6 +124,7 @@ where
                         "revisions" as "b"
                     WHERE
                         "ta"."account_id" IN ({})
+                        AND "ta"."relationship" = "{}"
                         AND "t"."transaction_id" = "ta"."transaction_id"
                         AND "t"."revision_id" = "b"."revision_id"
                         AND "t"."transaction_id" = "bt"."transaction_id"
@@ -129,6 +133,42 @@ where
                     LIMIT {} OFFSET {}
                     "#,
                 "?,".repeat(account_ids.len()).trim_end_matches(","),
+                AccountTransactionType::Receives.to_string(),
+                since,
+                until,
+                limit,
+                cursor.filter.skip
+            );
+            let mut query = sqlx::query(&sql);
+            for id in account_ids.iter() {
+                query = query.bind(id.to_string());
+            }
+            query.fetch_all(executor).await
+        }
+        PrimaryFilter::Spends(account_ids) => {
+            let sql = format!(
+                r#"
+                    SELECT
+                        "bt"."blob",
+                        "b"."blob",
+                        "b"."revision_id"
+                    FROM
+                        "transaction_accounts" as "ta",
+                        "transactions" as "t",
+                        "base_transactions" as "bt",
+                        "revisions" as "b"
+                    WHERE
+                        "ta"."account_id" IN ({})
+                        AND "ta"."relationship" = "{}"
+                        AND "t"."transaction_id" = "ta"."transaction_id"
+                        AND "t"."revision_id" = "b"."revision_id"
+                        AND "t"."transaction_id" = "bt"."transaction_id"
+                        {} {}
+                    ORDER BY "ta"."created_at" DESC
+                    LIMIT {} OFFSET {}
+                    "#,
+                "?,".repeat(account_ids.len()).trim_end_matches(","),
+                AccountTransactionType::Spends.to_string(),
                 since,
                 until,
                 limit,
@@ -145,7 +185,8 @@ where
                 r#"
                     SELECT
                         "bt"."blob",
-                        "b"."blob"
+                        "b"."blob",
+                        "b"."revision_id"
                     FROM
                         "transactions" as "t",
                         "base_transactions" as "bt",
@@ -175,7 +216,8 @@ where
                 r#"
                     SELECT
                         "bt"."blob",
-                        "b"."blob"
+                        "b"."blob",
+                        "b"."revision_id"
                     FROM
                         "transactions" as "t",
                         "base_transactions" as "bt",
@@ -206,7 +248,8 @@ where
                 r#"
                   SELECT
                       "bt"."blob",
-                      "b"."blob"
+                      "b"."blob",
+                      "b"."revision_id"
                   FROM
                       "transactions" as "t",
                       "base_transactions" as "bt",
@@ -236,7 +279,8 @@ where
                 r#"
                     SELECT
                         "bt"."blob",
-                        "b"."blob"
+                        "b"."blob",
+                        "b"."revision_id"
                     FROM
                         "transactions" as "t",
                         "base_transactions" as "bt",
@@ -266,9 +310,16 @@ where
                 .try_get::<Vec<u8>, usize>(1)
                 .map_err(|e| Error::Storage(e.to_string()))?;
 
+            let revision_id = RevId::from_str(
+                &row.try_get::<String, usize>(2)
+                    .map_err(|e| Error::Storage(e.to_string()))?,
+            )
+            .map_err(|e| Error::Storage(e.to_string()))?;
+
             Ok((
                 from_slice::<BaseTx>(&base_tx)?,
                 from_slice::<Revision>(&revision)?,
+                revision_id,
             ))
         })
         .collect::<Result<Vec<_>, Error>>()?;
@@ -340,13 +391,14 @@ impl SQLite {
         CREATE INDEX IF NOT EXISTS "spent_by" ON "payments" ("to", "status", "spent_by", "is_negative");
         CREATE TABLE IF NOT EXISTS "transaction_accounts" (
             "id" INTEGER PRIMARY KEY AUTOINCREMENT,
+            "relationship" VARCHAR(6) NOT NULL,
             "account_id" VARCHAR(64) NOT NULL,
             "transaction_id" VARCHAR(66) NOT NULL,
             "type" INTEGER NOT NULL,
             "created_at" DATETIME DEFAULT CURRENT_TIMESTAMP,
             "updated_at" DATETIME DEFAULT CURRENT_TIMESTAMP
         );
-        CREATE UNIQUE INDEX IF NOT EXISTS "unique_account_transaction" ON "transaction_accounts" ("account_id", "transaction_id");
+        CREATE UNIQUE INDEX IF NOT EXISTS "unique_account_transaction" ON "transaction_accounts" ("account_id", "transaction_id", "relationship");
         CREATE INDEX IF NOT EXISTS "sorted_account_transaction" ON "transaction_accounts" ("account_id", "id" desc);
         "#,
         )
@@ -615,7 +667,8 @@ impl Storage for SQLite {
 
             let mut iteration_result = candidates
                 .into_iter()
-                .filter(|(base, revision)| cursor.matches(base, revision))
+                .filter(|(base, revision, revision_id)| cursor.matches(base, revision, revision_id))
+                .map(|(base, revision, _)| (base, revision))
                 .collect::<Vec<_>>();
 
             results.append(&mut iteration_result);

utxo/src/tests/tx.rs

@@ -40,7 +40,7 @@ async fn multi_account_transfers() {
     );
 
     let filter = Filter {
-        accounts: vec![accounts[0].clone()],
+        spends: vec![accounts[0].clone()],
         typ: vec![Type::Exchange],
         ..Default::default()
     };
@@ -51,7 +51,7 @@ async fn multi_account_transfers() {
 
     for _ in &accounts {
         let filter = Filter {
-            accounts: vec![accounts[0].clone()],
+            spends: vec![accounts[0].clone()],
             typ: vec![Type::Exchange],
             ..Default::default()
         };

utxo/src/transaction/base_tx.rs

@@ -3,7 +3,7 @@ use crate::{
     payment::PaymentTo,
     storage::to_bytes,
     transaction::{Error, Revision, Type},
-    AccountId, Asset, PaymentFrom, Status, TxId,
+    Accounts, Asset, PaymentFrom, Status, TxId,
 };
 use chrono::{serde::ts_milliseconds, DateTime, Utc};
 use serde::{Deserialize, Serialize};
@@ -139,22 +139,7 @@ impl BaseTx {
     /// Returns a unique list of accounts involved in this transaction.
     ///
     /// Accounts are sorted and unique, and they include the accounts that spent and that receives
-    pub fn accounts(&self) -> Vec<AccountId> {
-        let mut accounts = self
-            .creates
-            .iter()
-            .map(|x| x.to.clone())
-            .collect::<Vec<_>>();
-
-        accounts.extend(
-            self.spends
-                .iter()
-                .map(|x| x.from.clone())
-                .collect::<Vec<_>>(),
-        );
-
-        accounts.sort();
-        accounts.dedup();
-        accounts
+    pub fn accounts(&self) -> Accounts {
+        self.into()
     }
 }

utxo/src/transaction/mod.rs

@@ -131,8 +131,14 @@ impl Transaction {
             FilterableValue::Type(self.typ),
         ];
 
-        for account in self.accounts() {
-            filters.push(FilterableValue::Account(account));
+        let accounts = self.accounts();
+
+        for account in accounts.spends {
+            filters.push(FilterableValue::Spends(account));
+        }
+
+        for account in accounts.receives {
+            filters.push(FilterableValue::Receives(account));
         }
 
         for tag in &self.revision.tags {