Feat: saving last block query for next fetching

apps/extension/src/background/keyring/handler.ts

@@ -5,6 +5,7 @@ import {
   QueryAccountsMsg,
   QueryBalancesMsg,
   QueryDefaultAccountMsg,
+  QueryLastBlocksMsg,
   ShieldedSyncMsg,
   VerifyArbitraryMsg,
 } from "provider/messages";
@@ -63,6 +64,8 @@ export const getHandler: (service: KeyRingService) => Handler = (service) => {
         return handleQueryBalancesMsg(service)(env, msg as QueryBalancesMsg);
       case ShieldedSyncMsg:
         return handleShieldedSyncMsg(service)(env, msg as ShieldedSyncMsg);
+      case QueryLastBlocksMsg:
+        return handleRequestLastBlock(service)(env, msg as QueryLastBlocksMsg);
       case SetActiveAccountMsg:
         return handleSetActiveAccountMsg(service)(
           env,
@@ -209,9 +212,9 @@ const handleQueryAccountsMsg: (
     const { query } = msg;
 
     const output =
-      query && query.accountId
-        ? await service.queryAccountById(query.accountId)
-        : await service.queryAccounts();
+      query && query.accountId ?
+        await service.queryAccountById(query.accountId)
+      : await service.queryAccounts();
 
     return output;
   };
@@ -236,8 +239,16 @@ const handleQueryBalancesMsg: (
 const handleShieldedSyncMsg: (
   service: KeyRingService
 ) => InternalHandler<ShieldedSyncMsg> = (service) => {
+  return async (_, { startHeight, lastHeight }) => {
+    return await service.shieldedSync(startHeight, lastHeight);
+  };
+};
+
+const handleRequestLastBlock: (
+  service: KeyRingService
+) => InternalHandler<QueryLastBlocksMsg> = (service) => {
   return async () => {
-    return await service.shieldedSync();
+    return await service.queryLastBlock();
   };
 };
 

apps/extension/src/background/keyring/init.ts

@@ -5,6 +5,7 @@ import {
   QueryAccountsMsg,
   QueryBalancesMsg,
   QueryDefaultAccountMsg,
+  QueryLastBlocksMsg,
   ShieldedSyncMsg,
   VerifyArbitraryMsg,
 } from "provider/messages";
@@ -40,6 +41,7 @@ export function init(router: Router, service: KeyRingService): void {
   router.registerMessage(QueryDefaultAccountMsg);
   router.registerMessage(QueryBalancesMsg);
   router.registerMessage(ShieldedSyncMsg);
+  router.registerMessage(QueryLastBlocksMsg);
   router.registerMessage(QueryParentAccountsMsg);
   router.registerMessage(SaveAccountSecretMsg);
   router.registerMessage(ScanAccountsMsg);

apps/extension/src/background/keyring/keyring.ts

@@ -907,6 +907,16 @@ export class KeyRing {
     return Result.ok(null);
   }
 
+  async queryLastBlock() {
+    try {
+      const query = await this.sdkService.getQuery();
+      const bigInitLastBlock = await query.query_last_block();
+      return Number(bigInitLastBlock);
+    } catch (e) {
+      console.warn(e);
+    }
+  }
+
   async queryBalances(
     owner: string,
     tokens: string[]

apps/extension/src/background/keyring/service.ts

@@ -482,13 +482,23 @@ export class KeyRingService {
     return Sdk.has_masp_params();
   }
 
-  async shieldedSync(): Promise<void> {
-    const vks = (await this.vaultStorage.findAll(KeyStore))
-      .filter((a) => a.public.type === AccountType.ShieldedKeys)
-      .map((a) => a.public.owner);
+  async shieldedSync(startHeight?: number, lastHeight?: number): Promise<void> {
+    try {
+      const vks = (await this.vaultStorage.findAll(KeyStore))
+        .filter((a) => a.public.type === AccountType.ShieldedKeys)
+        .map((a) => a.public.owner);
+      const start_height = startHeight ? BigInt(startHeight) : undefined;
+      const last_height = lastHeight ? BigInt(lastHeight) : undefined;
+
+      const query = await this.sdkService.getQuery();
+      await query.shielded_sync(vks, start_height, last_height);
+    } catch (error) {
+      console.warn(error);
+    }
+  }
 
-    const query = await this.sdkService.getQuery();
-    await query.shielded_sync(vks);
+  async queryLastBlock(): Promise<number | undefined> {
+    return await this._keyRing.queryLastBlock();
   }
 
   async queryBalances(

apps/extension/src/provider/InjectedNamada.ts

@@ -4,6 +4,7 @@ import {
   DerivedAccount,
   Namada as INamada,
   Signer as ISigner,
+  ShieldedSyncProps,
   SignArbitraryProps,
   SignatureResponse,
   TxMsgProps,
@@ -60,8 +61,17 @@ export class InjectedNamada implements INamada {
     >("balances", props);
   }
 
-  public async shieldedSync(): Promise<void> {
-    return await InjectedProxy.requestMethod<void, void>("shieldedSync");
+  public async shieldedSync(props: ShieldedSyncProps): Promise<void> {
+    return await InjectedProxy.requestMethod<ShieldedSyncProps, void>(
+      "shieldedSync",
+      props
+    );
+  }
+
+  public async queryLastBlock(): Promise<number | undefined> {
+    return await InjectedProxy.requestMethod<void, number | undefined>(
+      "queryLastBlock"
+    );
   }
 
   public async getChain(): Promise<Chain | undefined> {

apps/extension/src/provider/Namada.ts

@@ -3,6 +3,7 @@ import {
   Chain,
   DerivedAccount,
   Namada as INamada,
+  ShieldedSyncProps,
   SignArbitraryProps,
   SignatureResponse,
   TxMsgProps,
@@ -22,6 +23,7 @@ import {
   QueryAccountsMsg,
   QueryBalancesMsg,
   QueryDefaultAccountMsg,
+  QueryLastBlocksMsg,
   ShieldedSyncMsg,
   VerifyArbitraryMsg,
 } from "./messages";
@@ -126,10 +128,20 @@ export class Namada implements INamada {
     );
   }
 
-  public async shieldedSync(): Promise<void> {
+  public async shieldedSync({
+    startHeight,
+    lastHeight,
+  }: ShieldedSyncProps): Promise<void> {
     return await this.requester?.sendMessage(
       Ports.Background,
-      new ShieldedSyncMsg()
+      new ShieldedSyncMsg(startHeight, lastHeight)
+    );
+  }
+
+  public async queryLastBlock(): Promise<number | undefined> {
+    return await this.requester?.sendMessage(
+      Ports.Background,
+      new QueryLastBlocksMsg()
     );
   }
 

apps/extension/src/provider/messages.ts

@@ -39,6 +39,7 @@ enum MessageType {
   CheckDurability = "check-durability",
   ApproveSignArbitrary = "approve-sign-arbitrary",
   VerifyArbitrary = "verify-arbitrary",
+  QueryLastBlock = "query-last-block",
 }
 
 /**
@@ -173,7 +174,10 @@ export class ShieldedSyncMsg extends Message<void> {
     return MessageType.ShieldedSync;
   }
 
-  constructor() {
+  constructor(
+    public readonly startHeight?: number,
+    public readonly lastHeight?: number
+  ) {
     super();
   }
 
@@ -188,6 +192,26 @@ export class ShieldedSyncMsg extends Message<void> {
   }
 }
 
+export class QueryLastBlocksMsg extends Message<number | undefined> {
+  public static type(): MessageType {
+    return MessageType.QueryLastBlock;
+  }
+
+  constructor() {
+    super();
+  }
+
+  validate(): void {}
+
+  route(): string {
+    return Route.KeyRing;
+  }
+
+  type(): string {
+    return QueryLastBlocksMsg.type();
+  }
+}
+
 export class QueryDefaultAccountMsg extends Message<
   DerivedAccount | undefined
 > {

apps/namada-interface/src/App/AccountOverview/DerivedAccounts/DerivedAccounts.tsx

@@ -142,7 +142,7 @@ const DerivedAccounts = (): JSX.Element => {
                           // Show native token first
                           return tokenType === chain.currency.token ? 1 : -1;
                         })
-                        .filter(([_, amount]) => amount.isGreaterThan(0))
+                        .filter(([_, amount]) => amount?.isGreaterThan(0))
                         .map(([token, amount]) => {
                           return (
                             <TokenBalance key={`${address}-${token}`}>

apps/namada-interface/src/App/Token/TokenSend/TokenSend.tsx

@@ -70,11 +70,11 @@ const TokenSend = (): JSX.Element => {
 
   const shieldedAccountsWithBalance = accounts.filter(
     ({ details }) => details.isShielded
-  ).filter(({ balance }) => Object.values(balance).some((amount) => amount.isGreaterThan(0)));
+  ).filter(({ balance }) => Object.values(balance).some((amount) => amount?.isGreaterThan(0)));
 
   const transparentAccountsWithBalance = accounts.filter(
     ({ details }) => !details.isShielded
-  ).filter(({ balance }) => Object.values(balance).some((amount) => amount.isGreaterThan(0)));
+  ).filter(({ balance }) => Object.values(balance).some((amount) => amount?.isGreaterThan(0)));
 
   const shieldedTokenData = accountsWithBalanceIntoSelectData(
     shieldedAccountsWithBalance

apps/namada-interface/src/slices/accounts.ts

@@ -185,6 +185,8 @@ const accountsAtom = (() => {
   );
 })();
 
+const LATEST_SYNCED_HEIGHT_STORAGE = "latest-synced-height"
+
 const balancesAtom = (() => {
   const base = atom<{ [address: Address]: TokenBalances }>({});
 
@@ -223,7 +225,13 @@ const balancesAtom = (() => {
         set(base, { ...get(base), [address]: balance });
       });
 
-      await namada.sync();
+      const lastHeight = await namada.queryLastBlock();
+      const startHeightStorage = Number(localStorage.getItem(LATEST_SYNCED_HEIGHT_STORAGE));
+      const startHeight = startHeightStorage ? startHeightStorage : undefined;
+      await namada.sync(startHeight,lastHeight);
+      if(lastHeight){
+        localStorage.setItem(LATEST_SYNCED_HEIGHT_STORAGE, lastHeight.toString())
+      }
 
       const shieldedBalances = await Promise.all(
         queryBalance(namada, shieldedAccounts, token)

packages/integrations/src/Namada.ts

@@ -90,11 +90,15 @@ export default class Namada implements Integration<Account, Signer> {
 
     // TODO: fix this
     return {
-      NAM: mapUndefined((amount) => new BigNumber(amount), balances[0].amount),
+      NAM: mapUndefined((amount) => new BigNumber(amount), balances[0]?.amount),
     };
   }
 
-  public async sync(): Promise<void> {
-    await this._namada?.shieldedSync();
+  public async sync(startHeight?: number, lastHeight?: number): Promise<void> {
+    await this._namada?.shieldedSync({ startHeight, lastHeight });
+  }
+
+  public async queryLastBlock(): Promise<number | undefined> {
+    return await this._namada?.queryLastBlock();
   }
 }

packages/integrations/src/types/Integration.ts

@@ -28,5 +28,5 @@ export interface Integration<T, S, U extends string = TokenType> {
     owner: string,
     tokens?: string[]
   ) => Promise<TokenBalances<U>>;
-  sync: (owners: string[]) => Promise<void>;
+  sync: (startHeight?: number, lastHeight?: number) => Promise<void>;
 }

packages/shared/lib/src/query.rs

@@ -18,8 +18,9 @@ use namada::sdk::masp_primitives::zip32::ExtendedFullViewingKey;
 use namada::sdk::rpc::{
     format_denominated_amount, get_public_key_at, get_token_balance, get_total_staked_tokens,
     query_epoch, query_native_token, query_proposal_by_id, query_proposal_votes,
-    query_storage_value,
+    query_storage_value, query_block
 };
+use namada::storage::BlockHeight;
 use namada::token;
 use namada::uint::I256;
 use std::collections::{BTreeMap, HashMap, HashSet};
@@ -255,7 +256,19 @@ impl Query {
         Ok(result)
     }
 
-    pub async fn shielded_sync(&self, owners: Box<[JsValue]>) -> Result<(), JsError> {
+    pub async fn query_last_block(&self) -> u64 {
+        let last_block_height_opt = query_block(&self.client).await.unwrap();
+        let last_block_height =
+            last_block_height_opt.map_or_else(BlockHeight::first, |block| block.height);
+        last_block_height.0
+    }
+
+    pub async fn shielded_sync(
+        &self,
+        owners: Box<[JsValue]>,
+        start_height: Option<u64>,
+        last_height: Option<u64>,
+    ) -> Result<(), JsError> {
         let owners: Vec<ViewingKey> = owners
             .into_iter()
             .filter_map(|owner| owner.as_string())
@@ -278,12 +291,22 @@ impl Query {
 
         let _ = shielded.save().await?;
 
+        let start_query_height = match start_height {
+            Some(x) => Some(BlockHeight(x)),
+            None => None
+        };
+
+        let last_query_height = match last_height {
+            Some(x) => Some(BlockHeight(x)),
+            None => None
+        };
+
         shielded
             .fetch(
                 &self.client,
                 &DefaultLogger::new(&WebIo),
-                None,
-                None,
+                start_query_height,
+                last_query_height,
                 1,
                 &[],
                 &owners,

packages/types/src/namada.ts

@@ -22,6 +22,11 @@ export type VerifyArbitraryProps = {
   signature: string;
 };
 
+export type ShieldedSyncProps = {
+  startHeight?: number;
+  lastHeight?: number;
+};
+
 export type BalancesProps = {
   owner: string;
   tokens: string[];
@@ -32,7 +37,8 @@ export interface Namada {
   balances(
     props: BalancesProps
   ): Promise<{ token: string; amount: string }[] | undefined>;
-  shieldedSync(): Promise<void>;
+  shieldedSync(props: ShieldedSyncProps): Promise<void>;
+  queryLastBlock(): Promise<number | undefined>;
   connect(chainId?: string): Promise<void>;
   isConnected(): Promise<boolean | undefined>;
   defaultAccount(chainId?: string): Promise<DerivedAccount | undefined>;