chore(app): fetching movement balances

Signed-off-by: Kaan Caglan <[email protected]>

Author: Caglankaan

app/src/lib/components/TransferCube/components/Cube/faces/Transfer.svelte

@@ -88,8 +88,14 @@ const transfer = async () => {
     // @ts-ignore
     transferState.set({ kind: "SWITCHING_TO_CHAIN" })
 
-    const rpcUrl = sourceChain.rpcs.find(rpc => rpc.type === "rpc")?.url
-    if (!rpcUrl) return toast.error(`no rpc available for ${sourceChain.display_name}`)
+    let rpcUrl = sourceChain.rpcs.find((rpc) => rpc.type === "rpc")?.url;
+      if (!rpcUrl)
+        return toast.error(`no rpc available for ${sourceChain.display_name}`);
+
+      if (!rpcUrl.endsWith("/v1", rpcUrl.length - 3)) {
+        rpcUrl = rpcUrl + "/v1";
+      }
+      rpcUrl = "https://aptos.testnet.bardock.movementlabs.xyz/v1"; //TODO: Remove this later its for test
 
     if (stepBefore($transferState, "CONFIRMING_TRANSFER")) {
       const chainInfo = await wallet.getNetwork()
@@ -111,13 +117,12 @@ const transfer = async () => {
         const client = createUnionClient({
           chainId: sourceChain.chain_id as AptosChainId,
           account: await wallet?.getAccount(),
-          transport: wallet as AptosBrowserWallet
+          transport: http(`${rpcUrl}`),
         })
 
         let realArgs = {
           ...transferArgs,
-          receiver: toHex(transferArgs.receiver),
-          baseToken: fromHex(transferArgs.baseToken, "string")
+          receiver: toHex(transferArgs.receiver)
         }
 
         const transfer = await client.transferAsset(realArgs)

app/src/lib/components/TransferCube/index.svelte

@@ -179,10 +179,19 @@ onMount(() => {
   const unsubscribe = transfer.subscribe(trans => {
     const chain = trans.intents.sourceChain
     if (chain) {
-      const userAddr =
-        chain.rpc_type === "evm"
-          ? $userAddress.evm?.canonical.toLowerCase()
-          : $userAddrCosmos?.canonical
+        let userAddr;
+      if (chain.rpc_type === "evm") {
+          userAddr = $userAddress.evm?.canonical.toLowerCase();
+        } else if (
+          chain.rpc_type === "aptos" ||
+          chain.chain_id === "movement"
+        ) {
+          // Use the aptos field for Movement
+          userAddr = $userAddress.aptos?.canonical.toLowerCase();
+        } else {
+          // Fallback to cosmos conversion if needed
+          userAddr = $userAddrCosmos?.canonical;
+        }
       if (userAddr && (previousSourceChain !== chain.chain_id || previousUserAddr !== userAddr)) {
         previousUserAddr = userAddr
         previousSourceChain = chain.chain_id

app/src/lib/stores/balances.ts

@@ -55,14 +55,14 @@ export async function queryBalances(chain: Chain, address: string) {
       await updateBalancesCosmos(chain, address)
       break
     case "aptos":
-      await updateBalancesAptos(chain, address)
+      await updateBalancesAptos(chain, address as Address)
       // console.error("aptos balance fetching currently unsupported")
       break
     default:
       console.error("invalid rpc type in balance fetching")
   }
 }
-export async function updateBalancesAptos(chain: Chain, address: string) {
+export async function updateBalancesAptos(chain: Chain, address: Address) {
   // Optionally mark expected tokens as "loading" (if chain.tokens exists)
   if (chain.tokens && chain.tokens.length) {
     chain.tokens.forEach(token =>
@@ -91,54 +91,60 @@ export async function updateBalancesAptos(chain: Chain, address: string) {
   `;
   const variables = {
     owner_address: address,
-    limit: 100,
-    offset: 0,
+    limit: 200,
+    offset: 0
   };
 
   // Set up the fetch options with appropriate headers.
   const fetchOptions: RequestInit = {
     method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      "X-Indexer-Client": "movement-explorer",
-      "X-Aptos-Client": "aptos-typescript-sdk/1.35.0",
-      "X-Aptos-Typescript-Sdk-Origin-Method": "queryIndexer",
-    },
     body: JSON.stringify({ query, variables }),
   };
 
   try {
     // Send the request to the Aptos indexer.
-    const response = await fetchJson("https://indexer.testnet.movementnetwork.xyz/v1/graphql", fetchOptions);
+    const response = await fetchJson(
+      "https://indexer.testnet.movementnetwork.xyz/v1/graphql",
+      fetchOptions
+    )
     if (response.isErr()) {
-      throw new Error(response.error.message);
+      throw new Error(response.error.message)
     }
-
     const data = response.value.data;
     if (!data || !data.current_fungible_asset_balances) {
       throw new Error("Invalid response data");
     }
 
-    // Process each token balance from the response.
-    data.current_fungible_asset_balances.forEach((token: any) => {
-      // Here, asset_type can be used as the key for storing the balance.
-      const tokenKey = token.asset_type;
-      const amount = token.amount;
-      updateBalance(chain.chain_id, tokenKey, { kind: "balance", amount, timestamp: Date.now() });
-    });
+    const aptosBalances = data.current_fungible_asset_balances
+      .filter((token: any) => token.metadata.token_standard === "v2")
+      .map((token: any) => ({
+        denom: token.asset_type,
+        amount: token.amount
+      }))
+
+    console.info("aptosBalances: ", aptosBalances)
+    aptosBalances.forEach(token => {
+      updateBalance(chain.chain_id, token.denom, {
+        kind: "balance",
+        amount: token.amount,
+        timestamp: Date.now()
+      })
+    })
   } catch (error: any) {
-    console.error("Error fetching Aptos balances", error);
+    console.error("Error fetching Aptos balances", error)
     // On error, update the balances for all tokens with an error state.
     if (chain.tokens && chain.tokens.length) {
       chain.tokens.forEach(token =>
-        updateBalance(chain.chain_id, token.denom, { kind: "error", error: error.message, timestamp: Date.now() })
-      );
+        updateBalance(chain.chain_id, token.denom, {
+          kind: "error",
+          error: error.message,
+          timestamp: Date.now()
+        })
+      )
     }
   }
 }
 
-
-
 export async function updateBalancesEvm(chain: Chain, address: Address) {
   const denoms = chain.tokens.filter(tokens => isAddress(tokens.denom)).map(token => token.denom)
   balances.update(val => {

app/src/lib/utilities/neverthrow.ts

@@ -1,8 +1,8 @@
 import { ResultAsync } from "neverthrow"
 
-export const fetchJson = (url: string) =>
+export const fetchJson = (url: string, options?: RequestInit) =>
   ResultAsync.fromPromise(
-    fetch(url).then(response => {
+    fetch(url, options).then(response => {
       if (!response.ok) {
         throw new Error(`HTTP error! Status: ${response.status}`)
       }