@portal-hq/web 3.17.0 → 3.18.0

package/src/mpc/index.test.ts

@@ -80,6 +80,17 @@ import {
   mockBlockaidScanTokensResponse,
   mockBlockaidScanUrlRequest,
   mockBlockaidScanUrlResponse,
+  mockMeldCreateCustomerRequest,
+  mockMeldCreateCustomerResponse,
+  mockMeldSearchCustomerResponse,
+  mockMeldGetRetailQuoteRequest,
+  mockMeldGetRetailQuoteResponse,
+  mockMeldCreateRetailWidgetRequest,
+  mockMeldCreateRetailWidgetResponse,
+  mockMeldSearchRetailTransactionsResponse,
+  mockMeldGetRetailTransactionResponse,
+  mockMeldDiscoveryResponse,
+  mockMeldDiscoveryParams,
   mockBuildBatchedUserOpRequest,
   mockBuildBatchedUserOpResponse,
   mockBroadcastBatchedUserOpRequest,
@@ -4452,6 +4463,606 @@ describe('Mpc', () => {
     })
   })
 
+  describe('meldCreateCustomer', () => {
+    const args = mockMeldCreateCustomerRequest
+    const res = mockMeldCreateCustomerResponse
+
+    it('should successfully return the created customer', (done) => {
+      jest
+        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
+        .mockImplementation((message: any, origin?) => {
+          const { type, data } = message
+
+          expect(type).toEqual('portal:meld:createCustomer')
+          expect(data).toMatchObject(args)
+          expect(typeof message.traceId).toBe('string')
+          expect(origin).toEqual(mockHostOrigin)
+
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              origin: mockHostOrigin,
+              data: {
+                type: 'portal:meld:createCustomerResult',
+                data: res,
+              },
+            }),
+          )
+        })
+
+      mpc
+        .meldCreateCustomer(args)
+        .then((data) => {
+          expect(data).toEqual(res)
+          done()
+        })
+        .catch((_) => {
+          expect(0).toEqual(1)
+          done()
+        })
+    })
+
+    it('should error out if the iframe sends an error message', (done) => {
+      jest
+        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
+        .mockImplementationOnce((message: any, origin?) => {
+          const { type } = message
+
+          expect(type).toEqual('portal:meld:createCustomer')
+          expect(origin).toEqual(mockHostOrigin)
+
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              origin: mockHostOrigin,
+              data: {
+                type: 'portal:meld:createCustomerError',
+                data: { code: 1, message: 'test' },
+              },
+            }),
+          )
+        })
+
+      mpc
+        .meldCreateCustomer(args)
+        .then(() => {
+          expect(0).toEqual(1)
+          done()
+        })
+        .catch((e) => {
+          expect(e).toBeInstanceOf(PortalMpcError)
+          expect(e.message).toEqual('test')
+          expect(e.code).toEqual(1)
+          done()
+        })
+    })
+  })
+
+  describe('meldSearchCustomer', () => {
+    const res = mockMeldSearchCustomerResponse
+
+    it('should successfully return the customer data', (done) => {
+      jest
+        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
+        .mockImplementation((message: any, origin?) => {
+          const { type } = message
+
+          expect(type).toEqual('portal:meld:searchCustomer')
+          expect(origin).toEqual(mockHostOrigin)
+
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              origin: mockHostOrigin,
+              data: {
+                type: 'portal:meld:searchCustomerResult',
+                data: res,
+              },
+            }),
+          )
+        })
+
+      mpc
+        .meldSearchCustomer()
+        .then((data) => {
+          expect(data).toEqual(res)
+          done()
+        })
+        .catch((_) => {
+          expect(0).toEqual(1)
+          done()
+        })
+    })
+
+    it('should error out if the iframe sends an error message', (done) => {
+      jest
+        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
+        .mockImplementationOnce((_message: any, _origin?) => {
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              origin: mockHostOrigin,
+              data: {
+                type: 'portal:meld:searchCustomerError',
+                data: { code: 2, message: 'not found' },
+              },
+            }),
+          )
+        })
+
+      mpc
+        .meldSearchCustomer()
+        .then(() => {
+          expect(0).toEqual(1)
+          done()
+        })
+        .catch((e) => {
+          expect(e).toBeInstanceOf(PortalMpcError)
+          expect(e.code).toEqual(2)
+          done()
+        })
+    })
+  })
+
+  describe('meldGetRetailQuote', () => {
+    const args = mockMeldGetRetailQuoteRequest
+    const res = mockMeldGetRetailQuoteResponse
+
+    it('should successfully return the retail quote', (done) => {
+      jest
+        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
+        .mockImplementation((message: any, origin?) => {
+          const { type, data } = message
+
+          expect(type).toEqual('portal:meld:getRetailQuote')
+          expect(data).toMatchObject(args)
+          expect(typeof message.traceId).toBe('string')
+          expect(origin).toEqual(mockHostOrigin)
+
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              origin: mockHostOrigin,
+              data: {
+                type: 'portal:meld:getRetailQuoteResult',
+                data: res,
+              },
+            }),
+          )
+        })
+
+      mpc
+        .meldGetRetailQuote(args)
+        .then((data) => {
+          expect(data).toEqual(res)
+          done()
+        })
+        .catch((_) => {
+          expect(0).toEqual(1)
+          done()
+        })
+    })
+
+    it('should error out if the iframe sends an error message', (done) => {
+      jest
+        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
+        .mockImplementationOnce((_message: any, _origin?) => {
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              origin: mockHostOrigin,
+              data: {
+                type: 'portal:meld:getRetailQuoteError',
+                data: { code: 1, message: 'test' },
+              },
+            }),
+          )
+        })
+
+      mpc
+        .meldGetRetailQuote(args)
+        .then(() => {
+          expect(0).toEqual(1)
+          done()
+        })
+        .catch((e) => {
+          expect(e).toBeInstanceOf(PortalMpcError)
+          expect(e.message).toEqual('test')
+          expect(e.code).toEqual(1)
+          done()
+        })
+    })
+  })
+
+  describe('meldCreateRetailWidget', () => {
+    const args = mockMeldCreateRetailWidgetRequest
+    const res = mockMeldCreateRetailWidgetResponse
+
+    it('should successfully return the retail widget', (done) => {
+      jest
+        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
+        .mockImplementation((message: any, origin?) => {
+          expect(message.type).toEqual('portal:meld:createRetailWidget')
+          expect(message.data).toMatchObject(args)
+          expect(origin).toEqual(mockHostOrigin)
+
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              origin: mockHostOrigin,
+              data: { type: 'portal:meld:createRetailWidgetResult', data: res },
+            }),
+          )
+        })
+
+      mpc
+        .meldCreateRetailWidget(args)
+        .then((data) => {
+          expect(data).toEqual(res)
+          done()
+        })
+        .catch((_) => {
+          expect(0).toEqual(1)
+          done()
+        })
+    })
+  })
+
+  describe('meldSearchRetailTransactions', () => {
+    const res = mockMeldSearchRetailTransactionsResponse
+
+    it('should successfully return transactions without params', (done) => {
+      jest
+        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
+        .mockImplementation((message: any, origin?) => {
+          expect(message.type).toEqual('portal:meld:searchRetailTransactions')
+          expect(origin).toEqual(mockHostOrigin)
+
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              origin: mockHostOrigin,
+              data: { type: 'portal:meld:searchRetailTransactionsResult', data: res },
+            }),
+          )
+        })
+
+      mpc
+        .meldSearchRetailTransactions()
+        .then((data) => {
+          expect(data).toEqual(res)
+          done()
+        })
+        .catch((_) => {
+          expect(0).toEqual(1)
+          done()
+        })
+    })
+  })
+
+  describe('meldGetRetailTransactionBySession', () => {
+    const res = mockMeldGetRetailTransactionResponse
+
+    it('should successfully return a transaction by session ID', (done) => {
+      jest
+        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
+        .mockImplementation((message: any, origin?) => {
+          expect(message.type).toEqual('portal:meld:getRetailTransactionBySession')
+          expect(message.data).toEqual('ses-123')
+          expect(origin).toEqual(mockHostOrigin)
+
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              origin: mockHostOrigin,
+              data: { type: 'portal:meld:getRetailTransactionBySessionResult', data: res },
+            }),
+          )
+        })
+
+      mpc
+        .meldGetRetailTransactionBySession('ses-123')
+        .then((data) => {
+          expect(data).toEqual(res)
+          done()
+        })
+        .catch((_) => {
+          expect(0).toEqual(1)
+          done()
+        })
+    })
+  })
+
+  describe('meldGetRetailTransaction', () => {
+    const res = mockMeldGetRetailTransactionResponse
+
+    it('should successfully return a transaction by ID', (done) => {
+      jest
+        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
+        .mockImplementation((message: any, origin?) => {
+          expect(message.type).toEqual('portal:meld:getRetailTransaction')
+          expect(message.data).toEqual('tx-123')
+          expect(origin).toEqual(mockHostOrigin)
+
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              origin: mockHostOrigin,
+              data: { type: 'portal:meld:getRetailTransactionResult', data: res },
+            }),
+          )
+        })
+
+      mpc
+        .meldGetRetailTransaction('tx-123')
+        .then((data) => {
+          expect(data).toEqual(res)
+          done()
+        })
+        .catch((_) => {
+          expect(0).toEqual(1)
+          done()
+        })
+    })
+  })
+
+  describe('meldGetServiceProviders', () => {
+    const res = mockMeldDiscoveryResponse
+
+    it('should successfully return service providers without params', (done) => {
+      jest
+        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
+        .mockImplementation((message: any, origin?) => {
+          expect(message.type).toEqual('portal:meld:getServiceProviders')
+          expect(origin).toEqual(mockHostOrigin)
+
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              origin: mockHostOrigin,
+              data: { type: 'portal:meld:getServiceProvidersResult', data: res },
+            }),
+          )
+        })
+
+      mpc
+        .meldGetServiceProviders()
+        .then((data) => {
+          expect(data).toEqual(res)
+          done()
+        })
+        .catch((_) => {
+          expect(0).toEqual(1)
+          done()
+        })
+    })
+
+    it('should pass params to the iframe when provided', (done) => {
+      const params = mockMeldDiscoveryParams
+      jest
+        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
+        .mockImplementation((message: any, origin?) => {
+          expect(message.type).toEqual('portal:meld:getServiceProviders')
+          expect(message.data).toMatchObject(params)
+          expect(origin).toEqual(mockHostOrigin)
+
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              origin: mockHostOrigin,
+              data: { type: 'portal:meld:getServiceProvidersResult', data: res },
+            }),
+          )
+        })
+
+      mpc
+        .meldGetServiceProviders(params)
+        .then(() => done())
+        .catch((_) => {
+          expect(0).toEqual(1)
+          done()
+        })
+    })
+  })
+
+  describe('meldGetCountries', () => {
+    it('should successfully return countries', (done) => {
+      const res = mockMeldDiscoveryResponse
+      jest
+        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
+        .mockImplementation((message: any, origin?) => {
+          expect(message.type).toEqual('portal:meld:getCountries')
+          expect(origin).toEqual(mockHostOrigin)
+
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              origin: mockHostOrigin,
+              data: { type: 'portal:meld:getCountriesResult', data: res },
+            }),
+          )
+        })
+
+      mpc
+        .meldGetCountries()
+        .then((data) => {
+          expect(data).toEqual(res)
+          done()
+        })
+        .catch((_) => {
+          expect(0).toEqual(1)
+          done()
+        })
+    })
+
+    it('should error out if the iframe sends an error message', (done) => {
+      jest
+        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
+        .mockImplementationOnce((_message: any, _origin?) => {
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              origin: mockHostOrigin,
+              data: { type: 'portal:meld:getCountriesError', data: { code: 1, message: 'test' } },
+            }),
+          )
+        })
+
+      mpc
+        .meldGetCountries()
+        .then(() => {
+          expect(0).toEqual(1)
+          done()
+        })
+        .catch((e) => {
+          expect(e).toBeInstanceOf(PortalMpcError)
+          done()
+        })
+    })
+  })
+
+  describe('meldGetFiatCurrencies', () => {
+    it('should successfully return fiat currencies', (done) => {
+      const res = mockMeldDiscoveryResponse
+      jest
+        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
+        .mockImplementation((message: any, origin?) => {
+          expect(message.type).toEqual('portal:meld:getFiatCurrencies')
+          expect(origin).toEqual(mockHostOrigin)
+
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              origin: mockHostOrigin,
+              data: { type: 'portal:meld:getFiatCurrenciesResult', data: res },
+            }),
+          )
+        })
+
+      mpc
+        .meldGetFiatCurrencies()
+        .then((data) => {
+          expect(data).toEqual(res)
+          done()
+        })
+        .catch((_) => {
+          expect(0).toEqual(1)
+          done()
+        })
+    })
+  })
+
+  describe('meldGetCryptoCurrencies', () => {
+    it('should successfully return crypto currencies', (done) => {
+      const res = mockMeldDiscoveryResponse
+      jest
+        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
+        .mockImplementation((message: any, origin?) => {
+          expect(message.type).toEqual('portal:meld:getCryptoCurrencies')
+          expect(origin).toEqual(mockHostOrigin)
+
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              origin: mockHostOrigin,
+              data: { type: 'portal:meld:getCryptoCurrenciesResult', data: res },
+            }),
+          )
+        })
+
+      mpc.meldGetCryptoCurrencies().then((data) => { expect(data).toEqual(res); done() }).catch((_) => { expect(0).toEqual(1); done() })
+    })
+  })
+
+  describe('meldGetPaymentMethods', () => {
+    it('should successfully return payment methods', (done) => {
+      const res = mockMeldDiscoveryResponse
+      jest
+        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
+        .mockImplementation((message: any, origin?) => {
+          expect(message.type).toEqual('portal:meld:getPaymentMethods')
+          expect(origin).toEqual(mockHostOrigin)
+
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              origin: mockHostOrigin,
+              data: { type: 'portal:meld:getPaymentMethodsResult', data: res },
+            }),
+          )
+        })
+
+      mpc.meldGetPaymentMethods().then((data) => { expect(data).toEqual(res); done() }).catch((_) => { expect(0).toEqual(1); done() })
+    })
+  })
+
+  describe('meldGetDefaults', () => {
+    it('should successfully return defaults', (done) => {
+      const res = mockMeldDiscoveryResponse
+      jest
+        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
+        .mockImplementation((message: any, origin?) => {
+          expect(message.type).toEqual('portal:meld:getDefaults')
+          expect(origin).toEqual(mockHostOrigin)
+
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              origin: mockHostOrigin,
+              data: { type: 'portal:meld:getDefaultsResult', data: res },
+            }),
+          )
+        })
+
+      mpc.meldGetDefaults().then((data) => { expect(data).toEqual(res); done() }).catch((_) => { expect(0).toEqual(1); done() })
+    })
+  })
+
+  describe('meldGetBuyLimits', () => {
+    it('should successfully return buy limits', (done) => {
+      const res = mockMeldDiscoveryResponse
+      jest
+        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
+        .mockImplementation((message: any, origin?) => {
+          expect(message.type).toEqual('portal:meld:getBuyLimits')
+          expect(origin).toEqual(mockHostOrigin)
+
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              origin: mockHostOrigin,
+              data: { type: 'portal:meld:getBuyLimitsResult', data: res },
+            }),
+          )
+        })
+
+      mpc.meldGetBuyLimits().then((data) => { expect(data).toEqual(res); done() }).catch((_) => { expect(0).toEqual(1); done() })
+    })
+  })
+
+  describe('meldGetSellLimits', () => {
+    it('should successfully return sell limits', (done) => {
+      const res = mockMeldDiscoveryResponse
+      jest
+        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
+        .mockImplementation((message: any, origin?) => {
+          expect(message.type).toEqual('portal:meld:getSellLimits')
+          expect(origin).toEqual(mockHostOrigin)
+
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              origin: mockHostOrigin,
+              data: { type: 'portal:meld:getSellLimitsResult', data: res },
+            }),
+          )
+        })
+
+      mpc.meldGetSellLimits().then((data) => { expect(data).toEqual(res); done() }).catch((_) => { expect(0).toEqual(1); done() })
+    })
+  })
+
+  describe('meldGetKycLimits', () => {
+    it('should successfully return KYC limits', (done) => {
+      const res = mockMeldDiscoveryResponse
+      jest
+        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
+        .mockImplementation((message: any, origin?) => {
+          expect(message.type).toEqual('portal:meld:getKycLimits')
+          expect(origin).toEqual(mockHostOrigin)
+
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              origin: mockHostOrigin,
+              data: { type: 'portal:meld:getKycLimitsResult', data: res },
+            }),
+          )
+        })
+
+      mpc.meldGetKycLimits().then((data) => { expect(data).toEqual(res); done() }).catch((_) => { expect(0).toEqual(1); done() })
+    })
+  })
+
   describe('accountAbstractionBuildBatchedUserOp', () => {
     const args = mockBuildBatchedUserOpRequest
     const res = mockBuildBatchedUserOpResponse
@@ -4540,9 +5151,7 @@ describe('Mpc', () => {
         .mockImplementation((message: any, origin?) => {
           const { type, data } = message
 
-          expect(type).toEqual(
-            'portal:accountAbstraction:broadcastBatchedUserOp',
-          )
+          expect(type).toEqual('portal:accountAbstraction:broadcastBatchedUserOp')
           expect(data).toMatchObject(args)
           expect(typeof message.traceId).toBe('string')
           expect(origin).toEqual(mockHostOrigin)
@@ -4576,9 +5185,7 @@ describe('Mpc', () => {
         .mockImplementationOnce((message: any, origin?) => {
           const { type, data } = message
 
-          expect(type).toEqual(
-            'portal:accountAbstraction:broadcastBatchedUserOp',
-          )
+          expect(type).toEqual('portal:accountAbstraction:broadcastBatchedUserOp')
           expect(data).toMatchObject(args)
           expect(typeof message.traceId).toBe('string')
           expect(origin).toEqual(mockHostOrigin)
@@ -4611,4 +5218,194 @@ describe('Mpc', () => {
         })
     })
   })
-})
+
+
+ describe('walletNotOnDevice detection', () => {
+    const makeClient = (overrides: Record<string, any> = {}) => ({
+      id: 'client-test',
+      address: mockAddress,
+      ejectedAt: null as string | null,
+      custodian: { id: 'c', name: 'c' },
+      environment: { id: 'e', name: 'e', backupWithPortalEnabled: false, isMultiBackupEnabled: false },
+      isAccountAbstracted: false,
+      metadata: { namespaces: {} },
+      wallets: [] as any[],
+      ...overrides,
+    })
+
+    const makeWallet = (
+      curve: PortalCurve,
+      signingStatus: string,
+      backupStatus: string,
+    ) => ({
+      id: `wallet-${curve}`,
+      createdAt: '2024-01-01T00:00:00.000Z',
+      curve,
+      publicKey: 'pk',
+      signingSharePairs: [{ id: 'sp1', createdAt: '2024-01-01T00:00:00.000Z', status: signingStatus }],
+      backupSharePairs: [
+        {
+          id: 'bp1',
+          createdAt: '2024-01-01T00:00:00.000Z',
+          backupMethod: BackupMethods.password,
+          status: backupStatus,
+        },
+      ],
+    })
+
+    const dispatchReady = () => {
+      window.dispatchEvent(
+        new MessageEvent('message', {
+          origin: `https://${mockHost}`,
+          data: { type: 'portal:ready', data: true },
+        }),
+      )
+    }
+
+    const flushPromises = () => new Promise<void>((resolve) => setTimeout(resolve, 0))
+
+    beforeEach(() => {
+      jest.spyOn(mpc, 'getAddress').mockResolvedValue(mockAddress)
+      ;(mpc as any).waitForReadyMessage()
+    })
+
+    it('does not emit when client has no wallets (new user / initial setup)', async () => {
+      jest.spyOn(mpc, 'getClient').mockResolvedValue(makeClient({ wallets: [] }) as any)
+      jest.spyOn(mpc, 'checkSharesOnDevice').mockResolvedValue({ SECP256K1: false, ED25519: false })
+
+      dispatchReady()
+      await flushPromises()
+
+      expect(portalMock.triggerWalletNotOnDevice).not.toHaveBeenCalled()
+      expect(portalMock.triggerReady).toHaveBeenCalled()
+    })
+
+    it('does not emit when wallets exist but all signing share pairs are incomplete (setup in progress)', async () => {
+      jest.spyOn(mpc, 'getClient').mockResolvedValue(
+        makeClient({
+          wallets: [
+            makeWallet(PortalCurve.SECP256K1, 'incomplete', 'incomplete'),
+            makeWallet(PortalCurve.ED25519, 'incomplete', 'incomplete'),
+          ],
+        }) as any,
+      )
+      jest.spyOn(mpc, 'checkSharesOnDevice').mockResolvedValue({ SECP256K1: false, ED25519: false })
+
+      dispatchReady()
+      await flushPromises()
+
+      expect(portalMock.triggerWalletNotOnDevice).not.toHaveBeenCalled()
+      expect(portalMock.triggerReady).toHaveBeenCalled()
+    })
+
+    it('does not emit when wallet is present on device', async () => {
+      jest.spyOn(mpc, 'getClient').mockResolvedValue(
+        makeClient({
+          wallets: [
+            makeWallet(PortalCurve.SECP256K1, 'completed', 'completed'),
+            makeWallet(PortalCurve.ED25519, 'completed', 'completed'),
+          ],
+        }) as any,
+      )
+      jest.spyOn(mpc, 'checkSharesOnDevice').mockResolvedValue({ SECP256K1: true, ED25519: true })
+
+      dispatchReady()
+      await flushPromises()
+
+      expect(portalMock.triggerWalletNotOnDevice).not.toHaveBeenCalled()
+    })
+
+    it('emits walletNotOnDevice with isBackedUp=false when wallet is not on device and not backed up', async () => {
+      jest.spyOn(mpc, 'getClient').mockResolvedValue(
+        makeClient({
+          wallets: [
+            makeWallet(PortalCurve.SECP256K1, 'completed', 'incomplete'),
+            makeWallet(PortalCurve.ED25519, 'completed', 'incomplete'),
+          ],
+        }) as any,
+      )
+      jest.spyOn(mpc, 'checkSharesOnDevice').mockResolvedValue({ SECP256K1: false, ED25519: false })
+
+      dispatchReady()
+      await flushPromises()
+
+      expect(portalMock.triggerWalletNotOnDevice).toHaveBeenCalledWith({
+        clientId: 'client-test',
+        isBackedUp: false,
+        reason: 'storage_cleared',
+      })
+    })
+
+    it('emits walletNotOnDevice with isBackedUp=true when at least one backup is complete', async () => {
+      jest.spyOn(mpc, 'getClient').mockResolvedValue(
+        makeClient({
+          wallets: [makeWallet(PortalCurve.SECP256K1, 'completed', 'completed')],
+        }) as any,
+      )
+      jest.spyOn(mpc, 'checkSharesOnDevice').mockResolvedValue({ SECP256K1: false, ED25519: false })
+
+      dispatchReady()
+      await flushPromises()
+
+      expect(portalMock.triggerWalletNotOnDevice).toHaveBeenCalledWith({
+        clientId: 'client-test',
+        isBackedUp: true,
+        reason: 'storage_cleared',
+      })
+    })
+
+    it('does not emit for EVM-only client when SECP256K1 share is present (ED25519 absence is irrelevant)', async () => {
+      jest.spyOn(mpc, 'getClient').mockResolvedValue(
+        makeClient({
+          wallets: [makeWallet(PortalCurve.SECP256K1, 'completed', 'incomplete')],
+        }) as any,
+      )
+      jest.spyOn(mpc, 'checkSharesOnDevice').mockResolvedValue({ SECP256K1: true, ED25519: false })
+
+      dispatchReady()
+      await flushPromises()
+
+      expect(portalMock.triggerWalletNotOnDevice).not.toHaveBeenCalled()
+    })
+
+    it('emits for EVM-only client when SECP256K1 share is missing', async () => {
+      jest.spyOn(mpc, 'getClient').mockResolvedValue(
+        makeClient({
+          wallets: [makeWallet(PortalCurve.SECP256K1, 'completed', 'incomplete')],
+        }) as any,
+      )
+      jest.spyOn(mpc, 'checkSharesOnDevice').mockResolvedValue({ SECP256K1: false, ED25519: false })
+
+      dispatchReady()
+      await flushPromises()
+
+      expect(portalMock.triggerWalletNotOnDevice).toHaveBeenCalled()
+    })
+
+    it('does not emit when wallet is ejected (recovery is impossible)', async () => {
+      jest.spyOn(mpc, 'getClient').mockResolvedValue(
+        makeClient({
+          ejectedAt: '2024-06-01T00:00:00.000Z',
+          wallets: [makeWallet(PortalCurve.SECP256K1, 'completed', 'incomplete')],
+        }) as any,
+      )
+      jest.spyOn(mpc, 'checkSharesOnDevice').mockResolvedValue({ SECP256K1: false, ED25519: false })
+
+      dispatchReady()
+      await flushPromises()
+
+      expect(portalMock.triggerWalletNotOnDevice).not.toHaveBeenCalled()
+    })
+
+    it('still calls triggerReady when detection throws (detection must not block initialization)', async () => {
+      jest.spyOn(mpc, 'getClient').mockRejectedValue(new Error('network error'))
+      jest.spyOn(mpc, 'checkSharesOnDevice').mockRejectedValue(new Error('network error'))
+
+      dispatchReady()
+      await flushPromises()
+
+      expect(portalMock.triggerWalletNotOnDevice).not.toHaveBeenCalled()
+      expect(portalMock.triggerReady).toHaveBeenCalled()
+    })
+  })
+  })