@metamask/profile-sync-controller 20.0.0 → 22.0.0

package/dist/controllers/user-storage/constants.d.cts

@@ -3,4 +3,15 @@ export declare const BACKUPANDSYNC_FEATURES: {
     readonly accountSyncing: "accountSyncing";
     readonly contactSyncing: "contactSyncing";
 };
+/**
+ * Trace names for UserStorage syncing operations
+ */
+export declare const TraceName: {
+    readonly ContactSyncFull: "Contact Sync Full";
+    readonly ContactSyncSaveBatch: "Contact Sync Save Batch";
+    readonly ContactSyncUpdateRemote: "Contact Sync Update Remote";
+    readonly ContactSyncDeleteRemote: "Contact Sync Delete Remote";
+    readonly AccountSyncFull: "Account Sync Full";
+    readonly AccountSyncSaveIndividual: "Account Sync Save Individual";
+};
 //# sourceMappingURL=constants.d.cts.map

package/dist/controllers/user-storage/constants.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.cts","sourceRoot":"","sources":["../../../src/controllers/user-storage/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,sBAAsB;;;;CAIzB,CAAC"}
+{"version":3,"file":"constants.d.cts","sourceRoot":"","sources":["../../../src/controllers/user-storage/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,sBAAsB;;;;CAIzB,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,SAAS;;;;;;;CAUZ,CAAC"}

package/dist/controllers/user-storage/constants.d.mts

@@ -3,4 +3,15 @@ export declare const BACKUPANDSYNC_FEATURES: {
     readonly accountSyncing: "accountSyncing";
     readonly contactSyncing: "contactSyncing";
 };
+/**
+ * Trace names for UserStorage syncing operations
+ */
+export declare const TraceName: {
+    readonly ContactSyncFull: "Contact Sync Full";
+    readonly ContactSyncSaveBatch: "Contact Sync Save Batch";
+    readonly ContactSyncUpdateRemote: "Contact Sync Update Remote";
+    readonly ContactSyncDeleteRemote: "Contact Sync Delete Remote";
+    readonly AccountSyncFull: "Account Sync Full";
+    readonly AccountSyncSaveIndividual: "Account Sync Save Individual";
+};
 //# sourceMappingURL=constants.d.mts.map

package/dist/controllers/user-storage/constants.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.mts","sourceRoot":"","sources":["../../../src/controllers/user-storage/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,sBAAsB;;;;CAIzB,CAAC"}
+{"version":3,"file":"constants.d.mts","sourceRoot":"","sources":["../../../src/controllers/user-storage/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,sBAAsB;;;;CAIzB,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,SAAS;;;;;;;CAUZ,CAAC"}

package/dist/controllers/user-storage/constants.mjs

@@ -3,4 +3,17 @@ export const BACKUPANDSYNC_FEATURES = {
     accountSyncing: 'accountSyncing',
     contactSyncing: 'contactSyncing',
 };
+/**
+ * Trace names for UserStorage syncing operations
+ */
+export const TraceName = {
+    // Contact syncing traces
+    ContactSyncFull: 'Contact Sync Full',
+    ContactSyncSaveBatch: 'Contact Sync Save Batch',
+    ContactSyncUpdateRemote: 'Contact Sync Update Remote',
+    ContactSyncDeleteRemote: 'Contact Sync Delete Remote',
+    // Account syncing traces
+    AccountSyncFull: 'Account Sync Full',
+    AccountSyncSaveIndividual: 'Account Sync Save Individual',
+};
 //# sourceMappingURL=constants.mjs.map

package/dist/controllers/user-storage/constants.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"constants.mjs","sourceRoot":"","sources":["../../../src/controllers/user-storage/constants.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,sBAAsB,GAAG;IACpC,IAAI,EAAE,MAAM;IACZ,cAAc,EAAE,gBAAgB;IAChC,cAAc,EAAE,gBAAgB;CACxB,CAAC","sourcesContent":["export const BACKUPANDSYNC_FEATURES = {\n  main: 'main',\n  accountSyncing: 'accountSyncing',\n  contactSyncing: 'contactSyncing',\n} as const;\n"]}
+{"version":3,"file":"constants.mjs","sourceRoot":"","sources":["../../../src/controllers/user-storage/constants.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,sBAAsB,GAAG;IACpC,IAAI,EAAE,MAAM;IACZ,cAAc,EAAE,gBAAgB;IAChC,cAAc,EAAE,gBAAgB;CACxB,CAAC;AAEX;;GAEG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG;IACvB,yBAAyB;IACzB,eAAe,EAAE,mBAAmB;IACpC,oBAAoB,EAAE,yBAAyB;IAC/C,uBAAuB,EAAE,4BAA4B;IACrD,uBAAuB,EAAE,4BAA4B;IAErD,yBAAyB;IACzB,eAAe,EAAE,mBAAmB;IACpC,yBAAyB,EAAE,8BAA8B;CACjD,CAAC","sourcesContent":["export const BACKUPANDSYNC_FEATURES = {\n  main: 'main',\n  accountSyncing: 'accountSyncing',\n  contactSyncing: 'contactSyncing',\n} as const;\n\n/**\n * Trace names for UserStorage syncing operations\n */\nexport const TraceName = {\n  // Contact syncing traces\n  ContactSyncFull: 'Contact Sync Full',\n  ContactSyncSaveBatch: 'Contact Sync Save Batch',\n  ContactSyncUpdateRemote: 'Contact Sync Update Remote',\n  ContactSyncDeleteRemote: 'Contact Sync Delete Remote',\n\n  // Account syncing traces\n  AccountSyncFull: 'Account Sync Full',\n  AccountSyncSaveIndividual: 'Account Sync Save Individual',\n} as const;\n"]}

package/dist/controllers/user-storage/contact-syncing/controller-integration.cjs

@@ -5,6 +5,7 @@ const sync_utils_1 = require("./sync-utils.cjs");
 const utils_1 = require("./utils.cjs");
 const utils_2 = require("./utils.cjs");
 const storage_schema_1 = require("../../../shared/storage-schema.cjs");
+const constants_1 = require("../constants.cjs");
 /**
  * Creates a unique key for a contact based on chainId and address
  *
@@ -35,138 +36,163 @@ function createContactKey(contact) {
  *
  * @param config - Parameters used for syncing callbacks
  * @param options - Parameters used for syncing operations
+ * @returns Promise that resolves when contact synchronization is complete
  */
 async function syncContactsWithUserStorage(config, options) {
-    const { getMessenger, getUserStorageControllerInstance } = options;
+    const { getMessenger, getUserStorageControllerInstance, trace } = options;
     const { onContactSyncErroneousSituation, onContactUpdated, onContactDeleted, } = config;
-    try {
-        // Cannot perform sync, conditions not met
-        if (!(0, sync_utils_1.canPerformContactSyncing)(options)) {
-            return;
-        }
-        // Activate sync semaphore to prevent event loops
-        await getUserStorageControllerInstance().setIsContactSyncingInProgress(true);
-        // Get all local contacts from AddressBookController (exclude chain "*" contacts)
-        const localVisibleContacts = getMessenger()
-            .call('AddressBookController:list')
-            .filter((contact) => !(0, utils_2.isContactBridgedFromAccounts)(contact))
-            .filter((contact) => contact.address && contact.chainId && contact.name?.trim()) || [];
-        // Get remote contacts from user storage API
-        const remoteContacts = await getRemoteContacts(options);
-        // Filter remote contacts to exclude invalid ones (or empty array if no remote contacts)
-        const validRemoteContacts = remoteContacts?.filter((contact) => contact.address && contact.chainId && contact.name?.trim()) || [];
-        // Prepare maps for efficient lookup
-        const localContactsMap = new Map();
-        const remoteContactsMap = new Map();
-        localVisibleContacts.forEach((contact) => {
-            const key = createContactKey(contact);
-            localContactsMap.set(key, contact);
-        });
-        validRemoteContacts.forEach((contact) => {
-            const key = createContactKey(contact);
-            remoteContactsMap.set(key, contact);
-        });
-        // Lists to track contacts that need to be synced
-        const contactsToAddOrUpdateLocally = [];
-        const contactsToDeleteLocally = [];
-        const contactsToUpdateRemotely = [];
-        // SCENARIO 2 & 6: Process remote contacts - handle new device sync and remote updates
-        for (const remoteContact of validRemoteContacts) {
-            const key = createContactKey(remoteContact);
-            const localContact = localContactsMap.get(key);
-            // Handle remote contact based on its status and local existence
-            if (remoteContact.deletedAt) {
-                // SCENARIO 8: Remote deletion - should be applied locally if contact exists locally
-                if (localContact) {
-                    contactsToDeleteLocally.push(remoteContact);
-                }
-            }
-            else if (!localContact) {
-                // SCENARIO 2: New contact from remote - import to local
-                contactsToAddOrUpdateLocally.push(remoteContact);
-            }
-            else {
-                // SCENARIO 4 & 6: Contact exists on both sides - check for conflicts
-                const hasContentDifference = localContact.name !== remoteContact.name ||
-                    localContact.memo !== remoteContact.memo;
-                if (hasContentDifference) {
-                    // Check timestamps to determine which version to keep
-                    const localTimestamp = localContact.lastUpdatedAt || 0;
-                    const remoteTimestamp = remoteContact.lastUpdatedAt || 0;
-                    if (localTimestamp >= remoteTimestamp) {
-                        // Local is newer (or same age) - use local version
-                        contactsToUpdateRemotely.push(localContact);
+    // Cannot perform sync, conditions not met
+    if (!(0, sync_utils_1.canPerformContactSyncing)(options)) {
+        return;
+    }
+    // NOTE: Pre-sync operations (canPerformContactSyncing, AddressBookController:list, getRemoteContacts)
+    // are intentionally outside try-catch to let errors bubble up to Sentry for better debugging.
+    // Only "erroneous situation" errors during sync logic itself should be caught.
+    // Get all local contacts from AddressBookController (exclude chain "*" contacts)
+    const localVisibleContacts = getMessenger()
+        .call('AddressBookController:list')
+        .filter((contact) => !(0, utils_2.isContactBridgedFromAccounts)(contact))
+        .filter((contact) => contact.address && contact.chainId && contact.name?.trim()) || [];
+    // Get remote contacts from user storage API
+    const remoteContacts = await getRemoteContacts(options);
+    // Filter remote contacts to exclude invalid ones (or empty array if no remote contacts)
+    const validRemoteContacts = remoteContacts?.filter((contact) => contact.address && contact.chainId && contact.name?.trim()) || [];
+    const performSync = async () => {
+        try {
+            // Activate sync semaphore to prevent event loops
+            await getUserStorageControllerInstance().setIsContactSyncingInProgress(true);
+            // Prepare maps for efficient lookup
+            const localContactsMap = new Map();
+            const remoteContactsMap = new Map();
+            localVisibleContacts.forEach((contact) => {
+                const key = createContactKey(contact);
+                localContactsMap.set(key, contact);
+            });
+            validRemoteContacts.forEach((contact) => {
+                const key = createContactKey(contact);
+                remoteContactsMap.set(key, contact);
+            });
+            // Lists to track contacts that need to be synced
+            const contactsToAddOrUpdateLocally = [];
+            const contactsToDeleteLocally = [];
+            const contactsToUpdateRemotely = [];
+            // SCENARIO 2 & 6: Process remote contacts - handle new device sync and remote updates
+            for (const remoteContact of validRemoteContacts) {
+                const key = createContactKey(remoteContact);
+                const localContact = localContactsMap.get(key);
+                // Handle remote contact based on its status and local existence
+                if (remoteContact.deletedAt) {
+                    // SCENARIO 8: Remote deletion - should be applied locally if contact exists locally
+                    if (localContact) {
+                        contactsToDeleteLocally.push(remoteContact);
                     }
-                    else {
-                        // Remote is newer - use remote version
-                        contactsToAddOrUpdateLocally.push(remoteContact);
+                }
+                else if (!localContact) {
+                    // SCENARIO 2: New contact from remote - import to local
+                    contactsToAddOrUpdateLocally.push(remoteContact);
+                }
+                else {
+                    // SCENARIO 4 & 6: Contact exists on both sides - check for conflicts
+                    const hasContentDifference = localContact.name !== remoteContact.name ||
+                        localContact.memo !== remoteContact.memo;
+                    if (hasContentDifference) {
+                        // Check timestamps to determine which version to keep
+                        const localTimestamp = localContact.lastUpdatedAt || 0;
+                        const remoteTimestamp = remoteContact.lastUpdatedAt || 0;
+                        if (localTimestamp >= remoteTimestamp) {
+                            // Local is newer (or same age) - use local version
+                            contactsToUpdateRemotely.push(localContact);
+                        }
+                        else {
+                            // Remote is newer - use remote version
+                            contactsToAddOrUpdateLocally.push(remoteContact);
+                        }
                     }
+                    // Else: content is identical, no action needed
                 }
-                // Else: content is identical, no action needed
             }
-        }
-        // SCENARIO 1, 3 & 5: Process local contacts not in remote - handles first sync and new local contacts
-        for (const localContact of localVisibleContacts) {
-            const key = createContactKey(localContact);
-            const remoteContact = remoteContactsMap.get(key);
-            if (!remoteContact) {
-                // New local contact or first sync - add to remote
-                contactsToUpdateRemotely.push(localContact);
+            // SCENARIO 1, 3 & 5: Process local contacts not in remote - handles first sync and new local contacts
+            for (const localContact of localVisibleContacts) {
+                const key = createContactKey(localContact);
+                const remoteContact = remoteContactsMap.get(key);
+                if (!remoteContact) {
+                    // New local contact or first sync - add to remote
+                    contactsToUpdateRemotely.push(localContact);
+                }
             }
-        }
-        // Apply local deletions
-        for (const contact of contactsToDeleteLocally) {
-            try {
+            // Apply local deletions
+            // Note: Individual errors are intentionally NOT caught here to ensure they reach Sentry
+            // for debugging. Previous versions silently suppressed these errors which made
+            // troubleshooting contact sync issues difficult.
+            for (const contact of contactsToDeleteLocally) {
                 getMessenger().call('AddressBookController:delete', contact.chainId, contact.address);
                 if (onContactDeleted) {
                     onContactDeleted();
                 }
             }
-            catch (error) {
-                console.error('Error deleting contact:', error);
-            }
-        }
-        // Apply local additions/updates
-        for (const contact of contactsToAddOrUpdateLocally) {
-            if (!contact.deletedAt) {
-                try {
+            // Apply local additions/updates
+            // Note: Individual errors are intentionally NOT caught here to ensure they reach Sentry
+            // for debugging. Previous versions silently suppressed these errors which made
+            // troubleshooting contact sync issues difficult.
+            for (const contact of contactsToAddOrUpdateLocally) {
+                if (!contact.deletedAt) {
                     getMessenger().call('AddressBookController:set', contact.address, contact.name || '', contact.chainId, contact.memo || '', contact.addressType);
                     if (onContactUpdated) {
                         onContactUpdated();
                     }
                 }
-                catch (error) {
-                    console.error('Error updating contact:', error);
+            }
+            // Apply changes to remote storage
+            if (contactsToUpdateRemotely.length > 0) {
+                const updatedRemoteContacts = {};
+                for (const localContact of contactsToUpdateRemotely) {
+                    const key = createContactKey(localContact);
+                    updatedRemoteContacts[key] = {
+                        ...remoteContactsMap.get(key),
+                        ...localContact,
+                        lastUpdatedAt: Date.now(), // mark as updated
+                    };
                 }
+                // Save updated contacts to remote storage
+                await saveContactsToUserStorage(Object.values(updatedRemoteContacts), options);
             }
         }
-        // Apply changes to remote storage
-        if (contactsToUpdateRemotely.length > 0) {
-            const updatedRemoteContacts = {};
-            for (const localContact of contactsToUpdateRemotely) {
-                const key = createContactKey(localContact);
-                updatedRemoteContacts[key] = {
-                    ...remoteContactsMap.get(key),
-                    ...localContact,
-                    lastUpdatedAt: Date.now(), // mark as updated
-                };
+        catch (error) {
+            if (onContactSyncErroneousSituation) {
+                onContactSyncErroneousSituation('Error synchronizing contacts', {
+                    error,
+                });
+                // Re-throw the error to be handled by the caller
+                throw error;
             }
-            // Save updated contacts to remote storage
-            await saveContactsToUserStorage(Object.values(updatedRemoteContacts), options);
         }
-    }
-    catch (error) {
-        if (onContactSyncErroneousSituation) {
-            onContactSyncErroneousSituation('Error synchronizing contacts', {
-                error,
-            });
-            // Re-throw the error to be handled by the caller
-            throw error;
+        finally {
+            await getUserStorageControllerInstance().setIsContactSyncingInProgress(false);
         }
+    };
+    if (trace) {
+        // Gather pre-sync metrics for performance analysis
+        const initialLocalContacts = localVisibleContacts;
+        const initialValidRemoteContacts = validRemoteContacts;
+        await trace({
+            name: constants_1.TraceName.ContactSyncFull,
+            data: {
+                localContactCount: initialLocalContacts.length,
+                remoteContactCount: initialValidRemoteContacts.length,
+                isFirstSync: initialValidRemoteContacts.length === 0 &&
+                    initialLocalContacts.length > 0,
+                isNewDeviceSync: initialLocalContacts.length === 0 &&
+                    initialValidRemoteContacts.length > 0,
+                isRegularSync: initialLocalContacts.length > 0 &&
+                    initialValidRemoteContacts.length > 0,
+                hasDataToSync: initialLocalContacts.length > 0 ||
+                    initialValidRemoteContacts.length > 0,
+                expectedWorkload: initialLocalContacts.length + initialValidRemoteContacts.length,
+            },
+        }, performSync);
+        return;
     }
-    finally {
-        await getUserStorageControllerInstance().setIsContactSyncingInProgress(false);
-    }
+    await performSync();
 }
 exports.syncContactsWithUserStorage = syncContactsWithUserStorage;
 /**
@@ -198,19 +224,34 @@ async function getRemoteContacts(options) {
  *
  * @param contacts - The contacts to save to user storage
  * @param options - Parameters used for saving contacts
+ * @returns Promise that resolves when contacts are saved
  */
 async function saveContactsToUserStorage(contacts, options) {
-    const { getUserStorageControllerInstance } = options;
-    if (!contacts || contacts.length === 0) {
-        return;
-    }
-    // Convert each AddressBookEntry to UserStorageContactEntry format and create key-value pairs
-    const storageEntries = contacts.map((contact) => {
-        const key = createContactKey(contact);
-        const storageEntry = (0, utils_1.mapAddressBookEntryToUserStorageEntry)(contact);
-        return [key, JSON.stringify(storageEntry)];
-    });
-    await getUserStorageControllerInstance().performBatchSetStorage(storage_schema_1.USER_STORAGE_FEATURE_NAMES.addressBook, storageEntries);
+    const { getUserStorageControllerInstance, trace } = options;
+    const saveContacts = async () => {
+        if (!contacts || contacts.length === 0) {
+            return;
+        }
+        // Convert each AddressBookEntry to UserStorageContactEntry format and create key-value pairs
+        const storageEntries = contacts.map((contact) => {
+            const key = createContactKey(contact);
+            const storageEntry = (0, utils_1.mapAddressBookEntryToUserStorageEntry)(contact);
+            return [key, JSON.stringify(storageEntry)];
+        });
+        await getUserStorageControllerInstance().performBatchSetStorage(storage_schema_1.USER_STORAGE_FEATURE_NAMES.addressBook, storageEntries);
+    };
+    return trace
+        ? await trace({
+            name: constants_1.TraceName.ContactSyncSaveBatch,
+            data: {
+                contactCount: contacts.length,
+                // Performance scaling indicators
+                hasBatchOperations: contacts.length > 1,
+                chainCount: new Set(contacts.map((c) => c.chainId)).size,
+                hasMemosCount: contacts.filter((c) => c.memo?.length).length,
+            },
+        }, saveContacts)
+        : await saveContacts();
 }
 /**
  * Updates a single contact in remote storage without performing a full sync
@@ -218,24 +259,41 @@ async function saveContactsToUserStorage(contacts, options) {
  *
  * @param contact - The contact that was updated locally
  * @param options - Parameters used for syncing operations
+ * @returns Promise that resolves when the contact is updated
  */
 async function updateContactInRemoteStorage(contact, options) {
-    if (!(0, sync_utils_1.canPerformContactSyncing)(options) ||
-        !contact.address ||
-        !contact.chainId ||
-        !contact.name?.trim()) {
-        return;
-    }
-    const { getUserStorageControllerInstance } = options;
-    // Create an updated entry with timestamp
-    const updatedEntry = {
-        ...contact,
-        lastUpdatedAt: contact.lastUpdatedAt || Date.now(),
+    const { trace } = options;
+    const updateContact = async () => {
+        if (!(0, sync_utils_1.canPerformContactSyncing)(options) ||
+            !contact.address ||
+            !contact.chainId ||
+            !contact.name?.trim()) {
+            return;
+        }
+        const { getUserStorageControllerInstance } = options;
+        // Create an updated entry with timestamp
+        const updatedEntry = {
+            ...contact,
+            lastUpdatedAt: contact.lastUpdatedAt || Date.now(),
+        };
+        const key = createContactKey(contact);
+        const storageEntry = (0, utils_1.mapAddressBookEntryToUserStorageEntry)(updatedEntry);
+        // Save individual contact to remote storage
+        await getUserStorageControllerInstance().performSetStorage(`${storage_schema_1.USER_STORAGE_FEATURE_NAMES.addressBook}.${key}`, JSON.stringify(storageEntry));
     };
-    const key = createContactKey(contact);
-    const storageEntry = (0, utils_1.mapAddressBookEntryToUserStorageEntry)(updatedEntry);
-    // Save individual contact to remote storage
-    await getUserStorageControllerInstance().performSetStorage(`${storage_schema_1.USER_STORAGE_FEATURE_NAMES.addressBook}.${key}`, JSON.stringify(storageEntry));
+    if (trace) {
+        return await trace({
+            name: constants_1.TraceName.ContactSyncUpdateRemote,
+            data: {
+                chainId: contact.chainId,
+                // Performance indicators
+                hasTimestamp: Boolean(contact.lastUpdatedAt),
+                hasMemo: Boolean(contact.memo?.length),
+                isUpdate: Boolean(contact.lastUpdatedAt), // vs new contact
+            },
+        }, updateContact);
+    }
+    return await updateContact();
 }
 exports.updateContactInRemoteStorage = updateContactInRemoteStorage;
 /**
@@ -244,38 +302,45 @@ exports.updateContactInRemoteStorage = updateContactInRemoteStorage;
  *
  * @param contact - The contact that was deleted locally (contains at least address and chainId)
  * @param options - Parameters used for syncing operations
+ * @returns Promise that resolves when the contact is marked as deleted
  */
 async function deleteContactInRemoteStorage(contact, options) {
-    if (!(0, sync_utils_1.canPerformContactSyncing)(options) ||
-        !contact.address ||
-        !contact.chainId ||
-        !contact.name?.trim()) {
-        return;
-    }
-    const { getUserStorageControllerInstance } = options;
-    const key = createContactKey(contact);
-    try {
-        // Try to get the existing contact first
-        const existingContactJson = await getUserStorageControllerInstance().performGetStorage(`${storage_schema_1.USER_STORAGE_FEATURE_NAMES.addressBook}.${key}`);
-        if (existingContactJson) {
-            // Mark the existing contact as deleted
-            const existingStorageEntry = JSON.parse(existingContactJson);
-            const existingContact = (0, utils_1.mapUserStorageEntryToAddressBookEntry)(existingStorageEntry);
-            const now = Date.now();
-            const deletedContact = {
-                ...existingContact,
-                deletedAt: now,
-                lastUpdatedAt: now,
-            };
-            const deletedStorageEntry = (0, utils_1.mapAddressBookEntryToUserStorageEntry)(deletedContact);
-            // Save the deleted contact back to storage
-            await getUserStorageControllerInstance().performSetStorage(`${storage_schema_1.USER_STORAGE_FEATURE_NAMES.addressBook}.${key}`, JSON.stringify(deletedStorageEntry));
+    const { trace } = options;
+    const deleteContact = async () => {
+        if (!(0, sync_utils_1.canPerformContactSyncing)(options) ||
+            !contact.address ||
+            !contact.chainId ||
+            !contact.name?.trim()) {
+            return;
         }
-    }
-    catch {
-        // If contact doesn't exist in remote storage, no need to mark as deleted
-        console.warn('Contact not found in remote storage for deletion:', key);
-    }
+        const { getUserStorageControllerInstance } = options;
+        const key = createContactKey(contact);
+        try {
+            // Try to get the existing contact first
+            const existingContactJson = await getUserStorageControllerInstance().performGetStorage(`${storage_schema_1.USER_STORAGE_FEATURE_NAMES.addressBook}.${key}`);
+            if (existingContactJson) {
+                // Mark the existing contact as deleted
+                const existingStorageEntry = JSON.parse(existingContactJson);
+                const existingContact = (0, utils_1.mapUserStorageEntryToAddressBookEntry)(existingStorageEntry);
+                const now = Date.now();
+                const deletedContact = {
+                    ...existingContact,
+                    deletedAt: now,
+                    lastUpdatedAt: now,
+                };
+                const deletedStorageEntry = (0, utils_1.mapAddressBookEntryToUserStorageEntry)(deletedContact);
+                // Save the deleted contact back to storage
+                await getUserStorageControllerInstance().performSetStorage(`${storage_schema_1.USER_STORAGE_FEATURE_NAMES.addressBook}.${key}`, JSON.stringify(deletedStorageEntry));
+            }
+        }
+        catch {
+            // If contact doesn't exist in remote storage, no need to mark as deleted
+            console.warn('Contact not found in remote storage for deletion:', key);
+        }
+    };
+    return trace
+        ? await trace({ name: constants_1.TraceName.ContactSyncDeleteRemote }, deleteContact)
+        : await deleteContact();
 }
 exports.deleteContactInRemoteStorage = deleteContactInRemoteStorage;
 //# sourceMappingURL=controller-integration.cjs.map