feat(wallet-dashboard): update migration portfolio to include shared objects

apps/core/src/api/StardustIndexerClient.ts

@@ -0,0 +1,41 @@
+// Copyright (c) 2024 IOTA Stiftung
+// SPDX-License-Identifier: Apache-2.0
+
+import { StardustIndexerOutput } from '../utils';
+
+export class StardustIndexerClient {
+    private baseUrl: string;
+
+    constructor(baseUrl?: string) {
+        if (!baseUrl) {
+            throw new Error('Base URL for IndexerAPI is required.');
+        }
+        this.baseUrl = baseUrl;
+    }
+
+    private async request<T>(endpoint: string, options?: RequestInit): Promise<T> {
+        const url = `${this.baseUrl}${endpoint}`;
+        const response = await fetch(url, {
+            ...options,
+            headers: {
+                'Content-Type': 'application/json',
+                ...(options?.headers || {}),
+            },
+        });
+
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`API Error: ${response.status} ${response.statusText} - ${errorText}`);
+        }
+
+        return response.json();
+    }
+
+    public async getBasicResolvedOutputs(address: string): Promise<StardustIndexerOutput[]> {
+        return this.request(`/basic/resolved/${address}`);
+    }
+
+    public async getNftResolvedOutputs(address: string): Promise<StardustIndexerOutput[]> {
+        return this.request(`/nft/resolved/${address}`);
+    }
+}

apps/core/src/api/index.ts

@@ -2,3 +2,4 @@
 // SPDX-License-Identifier: Apache-2.0
 
 export * from './SentryHttpTransport';
+export * from './StardustIndexerClient';

apps/core/src/constants/migration.constants.ts

@@ -7,3 +7,6 @@ export const STARDUST_PACKAGE_ID =
     '000000000000000000000000000000000000000000000000000000000000107a';
 export const STARDUST_BASIC_OUTPUT_TYPE = `${STARDUST_PACKAGE_ID}::basic_output::BasicOutput<${IOTA_TYPE_ARG}>`;
 export const STARDUST_NFT_OUTPUT_TYPE = `${STARDUST_PACKAGE_ID}::nft_output::NftOutput<${IOTA_TYPE_ARG}>`;
+export const STARDUST_EXPIRATION_UNLOCK_CONDITION_TYPE = `${STARDUST_PACKAGE_ID}::expiration_unlock_condition::ExpirationUnlockCondition`;
+export const STARDUST_STORAGE_DEPOSIT_RETURN_UC_TYPE = `${STARDUST_PACKAGE_ID}::storage_deposit_return_unlock_condition::StorageDepositReturnUnlockCondition`;
+export const STARDUST_TIMELOCK_TYPE = `${STARDUST_PACKAGE_ID}::timelock_unlock_condition::TimelockUnlockCondition`;

apps/core/src/contexts/StardustIndexerClientContext.tsx

@@ -0,0 +1,41 @@
+// Copyright (c) 2024 IOTA Stiftung
+// SPDX-License-Identifier: Apache-2.0
+
+import { useContext, createContext, useState, useEffect } from 'react';
+import { StardustIndexerClient } from '../';
+import { getNetwork } from '@iota/iota-sdk/client';
+
+type StardustIndexerClientContextType = {
+    stardustIndexerClient: StardustIndexerClient | null;
+};
+
+export const StardustIndexerClientContext = createContext<StardustIndexerClientContextType | null>(
+    null,
+);
+
+export function useStardustIndexerClientContext(): StardustIndexerClientContextType {
+    const context = useContext(StardustIndexerClientContext);
+    if (!context) {
+        throw new Error('useStardustIndexerClient must be used within a StardustClientProvider');
+    }
+    return context;
+}
+
+export function useStardustIndexerClient(network?: string) {
+    const [stardustIndexerClient, setStardustIndexerClient] =
+        useState<StardustIndexerClient | null>(null);
+
+    const { stardustIndexer } = getNetwork(network || '');
+
+    useEffect(() => {
+        if (!stardustIndexer) {
+            setStardustIndexerClient(null);
+        } else {
+            setStardustIndexerClient(new StardustIndexerClient(stardustIndexer));
+        }
+    }, [stardustIndexer]);
+
+    return {
+        stardustIndexerClient,
+    };
+}

apps/core/src/contexts/index.ts

@@ -3,3 +3,4 @@
 
 export * from './ThemeContext';
 export * from './HiddenAssetsProvider';
+export * from './StardustIndexerClientContext';

apps/core/src/hooks/useGetAllOwnedObjects.ts

@@ -7,13 +7,24 @@ import { useQuery } from '@tanstack/react-query';
 
 const MAX_OBJECTS_PER_REQ = 10;
 
-export function useGetAllOwnedObjects(address: string, filter?: IotaObjectDataFilter) {
+export function useGetAllOwnedObjects(
+    address: string,
+    filter?: IotaObjectDataFilter,
+    mixinObjects?: () => Promise<IotaObjectData[]>,
+) {
     const client = useIotaClient();
+
     return useQuery({
-        queryKey: ['get-all-owned-objects', address, filter],
+        queryKey: ['get-all-owned-objects', address, filter, mixinObjects],
         queryFn: async () => {
             let cursor: string | undefined | null = null;
             const allData: IotaObjectData[] = [];
+
+            if (mixinObjects) {
+                const dependencyMixedObjects = await mixinObjects();
+                allData.push(...dependencyMixedObjects);
+            }
+
             // keep fetching until cursor is null or undefined
             do {
                 const { data: objectResponse, nextCursor } = await client.getOwnedObjects({

apps/core/src/utils/migration/index.ts

@@ -3,3 +3,4 @@
 
 export * from './createMigrationTransaction';
 export * from './types';
+export * from './mapStardustIndexerOutputs';

apps/core/src/utils/migration/mapStardustIndexerOutputs.ts

@@ -0,0 +1,77 @@
+// Copyright (c) 2024 IOTA Stiftung
+// SPDX-License-Identifier: Apache-2.0
+
+import {
+    STARDUST_BASIC_OUTPUT_TYPE,
+    STARDUST_EXPIRATION_UNLOCK_CONDITION_TYPE,
+    STARDUST_NFT_OUTPUT_TYPE,
+    STARDUST_STORAGE_DEPOSIT_RETURN_UC_TYPE,
+    STARDUST_TIMELOCK_TYPE,
+} from '../../constants';
+import { StardustIndexerOutput } from './types';
+
+export function mapStardustBasicOutputs(output: StardustIndexerOutput) {
+    return mapStardustOutput(output, STARDUST_BASIC_OUTPUT_TYPE);
+}
+
+export function mapStardustNftOutputs(output: StardustIndexerOutput) {
+    return mapStardustOutput(output, STARDUST_NFT_OUTPUT_TYPE);
+}
+
+function mapStardustOutput(output: StardustIndexerOutput, type: string) {
+    return {
+        objectId: output.id,
+        digest: '',
+        version: '',
+        type: type,
+        content: {
+            dataType: 'moveObject' as const,
+            type: STARDUST_NFT_OUTPUT_TYPE,
+            fields: {
+                balance: output.balance.value,
+                expiration_uc: output.expiration
+                    ? {
+                          type: STARDUST_EXPIRATION_UNLOCK_CONDITION_TYPE,
+                          fields: {
+                              owner: output.expiration.owner,
+                              return_address: output.expiration.return_address,
+                              unix_time: output.expiration.unix_time,
+                          },
+                      }
+                    : null,
+                id: {
+                    id: output.id,
+                },
+                metadata: [],
+                native_tokens: {
+                    type: '0x2::bag::Bag',
+                    fields: {
+                        id: {
+                            id: output.native_tokens.id,
+                        },
+                        size: output.native_tokens.size,
+                    },
+                },
+                sender: output.sender,
+                storage_deposit_return_uc: output.storage_deposit_return
+                    ? {
+                          type: STARDUST_STORAGE_DEPOSIT_RETURN_UC_TYPE,
+                          fields: {
+                              return_address: output.storage_deposit_return.return_address,
+                              return_amount: output.storage_deposit_return.return_address,
+                          },
+                      }
+                    : null,
+                tag: output.tag,
+                timelock_uc: output.timelock
+                    ? {
+                          fields: {
+                              unix_time: output.timelock.unix_time,
+                          },
+                          type: STARDUST_TIMELOCK_TYPE,
+                      }
+                    : null,
+            },
+        },
+    };
+}

apps/core/src/utils/migration/types.ts

@@ -2,12 +2,10 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { z } from 'zod';
-import { STARDUST_PACKAGE_ID } from '../../constants';
+import { STARDUST_EXPIRATION_UNLOCK_CONDITION_TYPE, STARDUST_PACKAGE_ID } from '../../constants';
 
 const ExpirationUnlockConditionSchema = z.object({
-    type: z.literal(
-        `${STARDUST_PACKAGE_ID}::expiration_unlock_condition::ExpirationUnlockCondition`,
-    ),
+    type: z.literal(STARDUST_EXPIRATION_UNLOCK_CONDITION_TYPE),
     fields: z.object({
         owner: z.string(),
         return_address: z.string(),
@@ -60,6 +58,38 @@ export const BasicOutputObjectSchema = CommonOutputObjectWithUcSchema.extend({
     sender: z.string().nullable().optional(),
 });
 
+const StardustIndexerOutputSchema = z.object({
+    id: z.string(),
+    balance: z.object({
+        value: z.number(),
+    }),
+    native_tokens: z.object({
+        id: z.string(),
+        size: z.number(),
+    }),
+    storage_deposit_return: z
+        .object({
+            return_address: z.string(),
+            return_amount: z.number(),
+        })
+        .nullable(),
+    timelock: z
+        .object({
+            unix_time: z.number(),
+        })
+        .nullable(),
+    expiration: z
+        .object({
+            owner: z.string(),
+            return_address: z.string(),
+            unix_time: z.number(),
+        })
+        .nullable(),
+    metadata: z.string().nullable(),
+    tag: z.string().nullable(),
+    sender: z.string().nullable(),
+});
+
 export const NftOutputObjectSchema = CommonOutputObjectWithUcSchema;
 
 export type ExpirationUnlockCondition = z.infer<typeof ExpirationUnlockConditionSchema>;
@@ -71,3 +101,4 @@ export type CommonOutputObject = z.infer<typeof CommonOutputObjectSchema>;
 export type CommonOutputObjectWithUc = z.infer<typeof CommonOutputObjectWithUcSchema>;
 export type BasicOutputObject = z.infer<typeof BasicOutputObjectSchema>;
 export type NftOutputObject = z.infer<typeof NftOutputObjectSchema>;
+export type StardustIndexerOutput = z.infer<typeof StardustIndexerOutputSchema>;

apps/wallet-dashboard/hooks/useGetStardustMigratableObjects.ts

@@ -5,20 +5,41 @@ import { useQuery } from '@tanstack/react-query';
 import { useGetCurrentEpochStartTimestamp } from '@/hooks';
 import { groupStardustObjectsByMigrationStatus } from '@/lib/utils';
 import {
+    mapStardustBasicOutputs,
+    mapStardustNftOutputs,
     STARDUST_BASIC_OUTPUT_TYPE,
     STARDUST_NFT_OUTPUT_TYPE,
     TimeUnit,
     useGetAllOwnedObjects,
+    useStardustIndexerClientContext,
 } from '@iota/core';
 
 export function useGetStardustMigratableObjects(address: string) {
     const { data: currentEpochMs } = useGetCurrentEpochStartTimestamp();
-    const { data: basicOutputObjects } = useGetAllOwnedObjects(address, {
-        StructType: STARDUST_BASIC_OUTPUT_TYPE,
-    });
-    const { data: nftOutputObjects } = useGetAllOwnedObjects(address, {
-        StructType: STARDUST_NFT_OUTPUT_TYPE,
-    });
+    const { stardustIndexerClient } = useStardustIndexerClientContext();
+    const { data: basicOutputObjects } = useGetAllOwnedObjects(
+        address,
+        {
+            StructType: STARDUST_BASIC_OUTPUT_TYPE,
+        },
+        async () => {
+            const outputs = await stardustIndexerClient?.getBasicResolvedOutputs(address);
+
+            return (outputs || []).map(mapStardustBasicOutputs);
+        },
+    );
+
+    const { data: nftOutputObjects } = useGetAllOwnedObjects(
+        address,
+        {
+            StructType: STARDUST_NFT_OUTPUT_TYPE,
+        },
+        async () => {
+            const outputs = await stardustIndexerClient?.getNftResolvedOutputs(address);
+
+            return (outputs || []).map(mapStardustNftOutputs);
+        },
+    );
 
     return useQuery({
         queryKey: [

apps/wallet-dashboard/lib/utils/migration/groupStardustObjectsByMigrationStatus.ts

@@ -33,17 +33,6 @@ export function groupStardustObjectsByMigrationStatus(
             continue;
         }
 
-        if (outputObjectFields.expiration_uc) {
-            const unlockableAddress =
-                outputObjectFields.expiration_uc.fields.unix_time <= epochUnix
-                    ? outputObjectFields.expiration_uc.fields.return_address
-                    : outputObjectFields.expiration_uc.fields.owner;
-
-            if (unlockableAddress !== address) {
-                continue;
-            }
-        }
-
         migratable.push(outputObject);
     }
 

apps/wallet-dashboard/lib/utils/timelock.ts

@@ -49,7 +49,7 @@ export function mapTimelockObjects(iotaObjects: IotaObjectData[]): TimelockedObj
         const fields = iotaObject.content.fields as unknown as TimelockedIotaResponse;
         return {
             id: fields.id,
-            locked: { value: BigInt(fields.locked) },
+            locked: { value: BigInt(fields?.locked || 0n) },
             expirationTimestampMs: Number(fields.expiration_timestamp_ms),
             label: fields.label,
         };

apps/wallet-dashboard/providers/AppProviders.tsx

@@ -13,6 +13,7 @@ import { useState } from 'react';
 import { KioskClientProvider, useLocalStorage } from '@iota/core';
 import { growthbook } from '@/lib/utils';
 import { ThemeProvider } from '@iota/core';
+import { StardustIndexerClientProvider } from './StardustIndexerClientProvider';
 
 growthbook.init();
 
@@ -34,25 +35,27 @@ export function AppProviders({ children }: React.PropsWithChildren) {
                     defaultNetwork={persistedNetwork}
                     onNetworkChange={handleNetworkChange}
                 >
-                    <KioskClientProvider>
-                        <WalletProvider
-                            autoConnect={true}
-                            theme={[
-                                {
-                                    variables: lightTheme,
-                                },
-                                {
-                                    selector: '.dark',
-                                    variables: darkTheme,
-                                },
-                            ]}
-                        >
-                            <ThemeProvider appId="iota-dashboard">
-                                {children}
-                                <Toaster />
-                            </ThemeProvider>
-                        </WalletProvider>
-                    </KioskClientProvider>
+                    <StardustIndexerClientProvider>
+                        <KioskClientProvider>
+                            <WalletProvider
+                                autoConnect={true}
+                                theme={[
+                                    {
+                                        variables: lightTheme,
+                                    },
+                                    {
+                                        selector: '.dark',
+                                        variables: darkTheme,
+                                    },
+                                ]}
+                            >
+                                <ThemeProvider appId="iota-dashboard">
+                                    {children}
+                                    <Toaster />
+                                </ThemeProvider>
+                            </WalletProvider>
+                        </KioskClientProvider>
+                    </StardustIndexerClientProvider>
                 </IotaClientProvider>
                 <ReactQueryDevtools initialIsOpen={false} />
             </QueryClientProvider>