/**
 * @jest-environment jsdom
 */

import { BackupMethods, MpcStatuses, PortalCurve } from '../index'
import Mpc from '.'
import {
  mockAddress,
  mockApikey,
  mockAssets,
  mockBackupConfig,
  mockBackupIds,
  mockBalances,
  mockBuiltTransaction,
  mockCipherText,
  mockClientResponse,
  mockEjectResult,
  mockEjectPrivateKeysResult,
  mockEvaluationResult,
  mockHost,
  mockNFTs,
  mockOrgBackupShares,
  mockQuoteArgs,
  mockRpcUrl,
  mockSharesOnDevice,
  mockSimulationResult,
  mockTransactionToEvaluate,
  mockTransactionToSimulate,
  mockYieldXyzGetYieldsRequest,
  mockYieldXyzGetYieldsResponse,
  mockYieldXyzEnterRequest,
  mockYieldXyzEnterResponse,
  mockYieldXyzExitRequest,
  mockYieldXyzExitResponse,
  mockYieldXyzGetBalancesRequest,
  mockYieldXyzGetBalancesResponse,
  mockYieldXyzGetHistoricalActionsRequest,
  mockYieldXyzGetHistoricalActionsResponse,
  mockYieldXyzManageYieldRequest,
  mockYieldXyzManageYieldResponse,
  mockYieldXyzTrackTransactionRequest,
  mockYieldXyzTrackTransactionResponse,
  mockYieldXyzGetTransactionResponse,
  mockLifiGetRoutesRequest,
  mockLifiGetRoutesResponse,
  mockLifiGetQuoteRequest,
  mockLifiGetQuoteResponse,
  mockLifiGetStatusRequest,
  mockLifiGetStatusResponse,
  mockLifiGetRouteStepRequest,
  mockLifiGetRouteStepResponse,
  mockZeroExQuoteV2Request,
  mockZeroExQuoteV2Response,
  mockZeroExSourcesV2Request,
  mockZeroExSourcesV2Response,
  mockZeroExPriceRequest,
  mockZeroExPriceResponse,
  mockZeroExOptions,
  mockScanAddressesRequest,
  mockScanAddressesResponse,
  mockScanEVMTxRequest,
  mockScanEVMTxResponse,
  mockScanEip712TxRequest,
  mockScanEip712TxResponse,
  mockScanSolanaTxRequest,
  mockScanSolanaTxResponse,
  mockScanNftRequest,
  mockScanNftResponse,
  mockScanTokenRequest,
  mockScanTokenResponse,
  mockScanUrlRequest,
  mockScanUrlResponse,
  mockBlockaidScanEvmTxRequest,
  mockBlockaidScanEvmTxResponse,
  mockBlockaidScanSolanaTxRequest,
  mockBlockaidScanSolanaTxResponse,
  mockBlockaidScanAddressRequest,
  mockBlockaidScanAddressResponse,
  mockBlockaidScanTokensRequest,
  mockBlockaidScanTokensResponse,
  mockBlockaidScanUrlRequest,
  mockBlockaidScanUrlResponse,
  mockBuildBatchedUserOpRequest,
  mockBuildBatchedUserOpResponse,
  mockBroadcastBatchedUserOpRequest,
  mockBroadcastBatchedUserOpResponse,
} from '../__mocks/constants'
import portalMock from '../__mocks/portal/portal'
import { PortalMpcError } from './errors'
import { BackupConfigs } from '../../types'

describe('Mpc', () => {
  const mockHostOrigin = `https://${mockHost}`

  let mpc: Mpc

  beforeEach(() => {
    jest.clearAllMocks()

    portalMock.host = mockHost
    mpc = new Mpc({
      portal: portalMock,
    })
  })

  describe('configureFirebaseStorage', () => {
    it('posts configure to iframe and bridges token requests from iframe', async () => {
      const postSpy = jest
        .spyOn(mpc.iframe!.contentWindow!, 'postMessage')
        .mockImplementation(() => {})

      mpc.configureFirebaseStorage({
        getToken: async (opts) =>
          opts?.forceRefresh ? 'firebase-jwt-refreshed' : 'firebase-jwt',
        tbsHost: 'backup.web.portalhq.io',
      })

      expect(postSpy).toHaveBeenNthCalledWith(
        1,
        {
          type: 'portal:firebase:configure',
          data: { tbsHost: 'backup.web.portalhq.io' },
        },
        mockHostOrigin,
      )

      const bridge = (mpc as unknown as { boundFirebaseTokenBridge: (e: MessageEvent) => void })
        .boundFirebaseTokenBridge
      bridge(
        new MessageEvent('message', {
          origin: mockHostOrigin,
          source: mpc.iframe!.contentWindow!,
          data: {
            type: 'portal:firebase:requestToken',
            data: { requestId: 'r1' },
          },
        }),
      )
      await new Promise<void>((resolve) => {
        setTimeout(resolve, 0)
      })
      expect(postSpy).toHaveBeenNthCalledWith(
        2,
        {
          type: 'portal:firebase:requestTokenResult',
          data: { requestId: 'r1', token: 'firebase-jwt' },
        },
        mockHostOrigin,
      )

      bridge(
        new MessageEvent('message', {
          origin: mockHostOrigin,
          source: mpc.iframe!.contentWindow!,
          data: {
            type: 'portal:firebase:requestToken',
            data: { requestId: 'r2', forceRefresh: true },
          },
        }),
      )
      await new Promise<void>((resolve) => {
        setTimeout(resolve, 0)
      })
      expect(postSpy).toHaveBeenNthCalledWith(
        3,
        {
          type: 'portal:firebase:requestTokenResult',
          data: { requestId: 'r2', token: 'firebase-jwt-refreshed' },
        },
        mockHostOrigin,
      )
    })
  })

  describe('backup', () => {
    const args = {
      backupMethod: BackupMethods.password,
      backupConfigs: mockBackupConfig,
      host: 'web.portalhq.io',
      mpcVersion: 'v6',
      featureFlags: {},
    }

    it('should successfully run backup', (done) => {
      jest
        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
        .mockImplementation((message: any, origin?) => {
          const { type, data } = message

          expect(type).toEqual('portal:wasm:backup')
          expect(data).toMatchObject(args)
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:wasm:backupProgress',
                data: {
                  status: MpcStatuses.EncryptingShare,
                  done: false,
                },
              },
            }),
          )

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:wasm:backupProgress',
                data: {
                  status: MpcStatuses.StoringShare,
                  done: false,
                },
              },
            }),
          )

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:wasm:backupProgress',
                data: {
                  status: MpcStatuses.Done,
                  done: true,
                },
              },
            }),
          )

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:wasm:backupResult',
                data: {
                  cipherText: 'test',
                },
              },
            }),
          )
        })

      const progressMock = jest.fn()
      mpc
        .backup(args, progressMock)
        .then((res) => {
          expect(res.cipherText).toEqual(mockCipherText)
          expect(progressMock).toHaveBeenCalledTimes(3)
          expect(progressMock.mock.calls[0]).toEqual([
            { status: MpcStatuses.EncryptingShare, done: false },
          ])
          expect(progressMock.mock.calls[1]).toEqual([
            { status: MpcStatuses.StoringShare, done: false },
          ])
          expect(progressMock.mock.calls[2]).toEqual([
            { status: MpcStatuses.Done, done: true },
          ])
          done()
        })
        .catch((e) => {
          console.error(e)
          expect(0).toEqual(1)
          done()
        })
    })

    it('should include encryption key when iframe returns custom backup response', (done) => {
      const setBackupStatusSpy = jest
        .spyOn(mpc, 'setBackupStatus')
        .mockResolvedValue(true as any)

      jest
        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
        .mockImplementation((message: any, origin?) => {
          const { type, data } = message

          expect(type).toEqual('portal:wasm:backup')
          expect(data).toMatchObject(args)
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:wasm:backupResult',
                data: {
                  cipherText: mockCipherText,
                  encryptionKey: 'custom-backup-key',
                  backupIds: mockBackupIds,
                },
              },
            }),
          )
        })

      mpc
        .backup(args)
        .then(async (res) => {
          expect(res.cipherText).toEqual(mockCipherText)
          expect(res.encryptionKey).toEqual('custom-backup-key')

          await res.storageCallback()

          expect(setBackupStatusSpy).toHaveBeenCalledTimes(1)
          expect(setBackupStatusSpy).toHaveBeenCalledWith(
            'STORED_CLIENT_BACKUP_SHARE',
            mockBackupIds,
          )
          done()
        })
        .catch((e) => {
          console.error(e)
          expect(0).toEqual(1)
          done()
        })
        .finally(() => {
          setBackupStatusSpy.mockRestore()
        })
    })

    it('should error out if the iframe sends an error message', (done) => {
      jest
        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
        .mockImplementationOnce((message: any, origin?) => {
          const { type, data } = message

          expect(type).toEqual('portal:wasm:backup')
          expect(data).toMatchObject(args)
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:wasm:backupError',
                data: {
                  code: 1,
                  message: 'test',
                },
              },
            }),
          )
        })

      mpc
        .backup(args)
        .then(() => {
          expect(0).toEqual(1)
          done()
        })
        .catch((e) => {
          expect(e).toBeInstanceOf(PortalMpcError)
          expect(e.message).toEqual('test')
          expect(e.code).toEqual(1)
          done()
        })
    })

    it('should error out if backupConfig is missing passswordStorage', (done) => {
      mpc
        .backup({
          backupMethod: BackupMethods.password,
          backupConfigs: {},
          host: 'web.portalhq.io',
          mpcVersion: 'v6',
          featureFlags: {},
        })
        .then(() => {
          expect(0).toEqual(1)
          done()
        })
        .catch((e) => {
          expect(e).toBeInstanceOf(Error)
          expect(e.message).toEqual('Password storage config is required')
          done()
        })
    })

    it('should error out if passswordStorage is missing password', (done) => {
      mpc
        .backup({
          backupMethod: BackupMethods.password,
          backupConfigs: {
            passwordStorage: {},
          } as BackupConfigs,
          host: 'web.portalhq.io',
          mpcVersion: 'v6',
          featureFlags: {},
        })
        .then(() => {
          expect(0).toEqual(1)
          done()
        })
        .catch((e) => {
          expect(e).toBeInstanceOf(Error)
          expect(e.message).toEqual('Password is required')
          done()
        })
    })

    it('should error out if password is weak', (done) => {
      mpc
        .backup({
          backupMethod: BackupMethods.password,
          backupConfigs: {
            passwordStorage: {
              password: 'wea',
            },
          },
          host: 'web.portalhq.io',
          mpcVersion: 'v6',
          featureFlags: {},
        })
        .then(() => {
          expect(0).toEqual(1)
          done()
        })
        .catch((e) => {
          expect(e).toBeInstanceOf(Error)
          expect(e.message).toEqual('Password must be at least 4 characters')
          done()
        })
    })

    it('should error out if backupMethod is invalid', (done) => {
      mpc
        .backup({
          backupMethod: 'INVALID_METHOD' as any,
          backupConfigs: {},
          host: 'web.portalhq.io',
          mpcVersion: 'v6',
          featureFlags: {},
        })
        .then(() => {
          expect(0).toEqual(1)
          done()
        })
        .catch((e) => {
          expect(e).toBeInstanceOf(Error)
          expect(e.message).toEqual(
            'Invalid backup method: INVALID_METHOD. Valid methods are: GDRIVE, PASSWORD, PASSKEY, CUSTOM, FIREBASE, UNKNOWN',
          )
          done()
        })
    })
  })

  describe('clearLocalWallet', () => {
    it('should clear local wallet', (done) => {
      jest
        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
        .mockImplementation((message: any, origin?) => {
          const { type, data } = message

          expect(type).toEqual('portal:destroy')
          expect(data).toMatchObject({})
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:destroyResult',
              },
            }),
          )
        })

      mpc
        .clearLocalWallet()
        .then((res) => {
          expect(res).toEqual(true)
          done()
        })
        .catch((_) => {
          expect(0).toEqual(1)
          done()
        })
    })
  })

  describe('generate', () => {
    const args = {
      host: 'web.portalhq.io',
      mpcVersion: 'v6',
      featureFlags: {},
    }

    it('should successfully run generate', (done) => {
      jest
        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
        .mockImplementation((message: any, origin?) => {
          const { type, data } = message

          expect(type).toEqual('portal:wasm:generate')
          expect(data).toMatchObject(args)
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:wasm:generateProgress',
                data: {
                  status: MpcStatuses.StoringShare,
                  done: false,
                },
              },
            }),
          )

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:wasm:generateProgress',
                data: {
                  status: MpcStatuses.Done,
                  done: true,
                },
              },
            }),
          )

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:wasm:generateResult',
                data: mockAddress,
              },
            }),
          )
        })

      const progressMock = jest.fn()
      mpc
        .generate(args, progressMock)
        .then((res) => {
          expect(res).toEqual(mockAddress)
          expect(progressMock).toHaveBeenCalledTimes(2)
          expect(progressMock.mock.calls[0]).toEqual([
            { status: MpcStatuses.StoringShare, done: false },
          ])
          expect(progressMock.mock.calls[1]).toEqual([
            { status: MpcStatuses.Done, done: true },
          ])
          done()
        })
        .catch((e) => {
          console.error(e)
          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, data } = message

          expect(type).toEqual('portal:wasm:generate')
          expect(data).toMatchObject(args)
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:wasm:generateError',
                data: {
                  code: 1,
                  message: 'test',
                },
              },
            }),
          )
        })

      mpc
        .generate(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('getAddress', () => {
    it('should successfully get address', (done) => {
      jest
        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
        .mockImplementation((message: any, origin?) => {
          const { type, data } = message

          expect(type).toEqual('portal:address')
          expect(data).toMatchObject({})
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:addressResult',
                data: mockAddress,
              },
            }),
          )
        })

      mpc
        .getAddress()
        .then((res) => {
          expect(res).toEqual(mockAddress)
          done()
        })
        .catch((_) => {
          expect(0).toEqual(1)
          done()
        })
    })
  })

  describe('recover', () => {
    const args = {
      backupMethod: BackupMethods.password,
      backupConfigs: mockBackupConfig,
      cipherText: mockCipherText,
      host: 'web.portalhq.io',
      mpcVersion: 'v6',
      featureFlags: {},
    }

    it('should successfully run recover', (done) => {
      jest
        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
        .mockImplementation((message: any, origin?) => {
          const { type, data } = message

          expect(type).toEqual('portal:wasm:recover')
          expect(data).toMatchObject(args)
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:wasm:recoverProgress',
                data: {
                  status: MpcStatuses.ReadingShare,
                  done: false,
                },
              },
            }),
          )

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:wasm:recoverProgress',
                data: {
                  status: MpcStatuses.StoringShare,
                  done: false,
                },
              },
            }),
          )

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:wasm:recoverProgress',
                data: {
                  status: MpcStatuses.Done,
                  done: true,
                },
              },
            }),
          )

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:wasm:recoverResult',
                data: mockAddress,
              },
            }),
          )
        })

      const progressMock = jest.fn()
      mpc
        .recover(args, progressMock)
        .then((res) => {
          expect(res).toEqual(mockAddress)
          expect(progressMock).toHaveBeenCalledTimes(3)
          expect(progressMock.mock.calls[0]).toEqual([
            { status: MpcStatuses.ReadingShare, done: false },
          ])
          expect(progressMock.mock.calls[1]).toEqual([
            { status: MpcStatuses.StoringShare, done: false },
          ])
          expect(progressMock.mock.calls[2]).toEqual([
            { status: MpcStatuses.Done, done: true },
          ])
          done()
        })
        .catch((e) => {
          console.error(e)
          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, data } = message

          expect(type).toEqual('portal:wasm:recover')
          expect(data).toMatchObject(args)
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:wasm:recoverError',
                data: {
                  code: 1,
                  message: 'test',
                },
              },
            }),
          )
        })

      mpc
        .recover(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('eject', () => {
    const args = {
      backupMethod: BackupMethods.password,
      backupConfigs: mockBackupConfig,
      cipherText: mockCipherText,
      host: 'web.portalhq.io',
      mpcVersion: 'v6',
      featureFlags: {},
      organizationBackupShare: 'test',
    }

    it('should successfully eject the wallet', (done) => {
      jest
        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
        .mockImplementation((message: any, origin?) => {
          const { type, data } = message

          expect(type).toEqual('portal:wasm:eject')
          expect(data).toMatchObject(args)
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:wasm:ejectResult',
                data: mockEjectResult,
              },
            }),
          )
        })

      mpc
        .eject(args)
        .then((res) => {
          expect(res).toEqual(mockEjectResult)
          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, data } = message

          expect(type).toEqual('portal:wasm:eject')
          expect(data).toMatchObject(args)
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:wasm:ejectError',
                data: {
                  code: 1,
                  message: 'test',
                },
              },
            }),
          )
        })

      mpc
        .eject(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('ejectPrivateKeys', () => {
    const args = {
      backupMethod: BackupMethods.password,
      backupConfigs: mockBackupConfig,
      cipherText: mockCipherText,
      host: 'web.portalhq.io',
      mpcVersion: 'v6',
      featureFlags: {},
      organizationBackupShares: mockOrgBackupShares,
    }

    it('should successfully eject the wallet', (done) => {
      jest
        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
        .mockImplementation((message: any, origin?) => {
          const { type, data } = message

          expect(type).toEqual('portal:wasm:ejectPrivateKeys')
          expect(data).toMatchObject(args)
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:wasm:ejectPrivateKeysResult',
                data: mockEjectPrivateKeysResult,
              },
            }),
          )
        })

      mpc
        .ejectPrivateKeys(args)
        .then((res) => {
          expect(res).toEqual(mockEjectPrivateKeysResult)
          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, data } = message

          expect(type).toEqual('portal:wasm:ejectPrivateKeys')
          expect(data).toMatchObject(args)
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:wasm:ejectPrivateKeysError',
                data: {
                  code: 1,
                  message: 'test',
                },
              },
            }),
          )
        })

      mpc
        .ejectPrivateKeys(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('rawSign', () => {
    const args = {
      curve: PortalCurve.SECP256K1,
      param: 'test',
    }

    it('should successfully raW sign', (done) => {
      jest
        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
        .mockImplementation((message: any, origin?) => {
          const { type, data } = message

          expect(type).toEqual('portal:mpc:rawSign')
          expect(data).toMatchObject(args)
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:mpc:rawSignResult',
                data: 'test',
              },
            }),
          )
        })

      mpc
        .rawSign(args.curve, args.param)
        .then((res) => {
          expect(res).toEqual('test')
          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, data } = message

          expect(type).toEqual('portal:mpc:rawSign')
          expect(data).toMatchObject(args)
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:mpc:rawSignError',
                data: {
                  code: 1,
                  message: 'test',
                },
              },
            }),
          )
        })

      mpc
        .rawSign(args.curve, args.param)
        .then(() => {
          expect(0).toEqual(1)
          done()
        })
        .catch((e) => {
          expect(e).toBeInstanceOf(PortalMpcError)
          expect(e.message).toEqual('test')
          expect(e.code).toEqual(1)
          done()
        })
    })
  })

  describe('sign', () => {
    const args = {
      chainId: 'test',
      method: 'test',
      params: 'test',
      rpcUrl: mockRpcUrl,
    }

    it('should successfully run sign', (done) => {
      jest
        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
        .mockImplementation((message: any, origin?) => {
          const { type, data } = message

          expect(type).toEqual('portal:wasm:sign')
          expect(data).toMatchObject(args)
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:wasm:signResult',
                data: 'test',
              },
            }),
          )
        })

      mpc
        .sign(args)
        .then((res) => {
          expect(res).toEqual('test')
          done()
        })
        .catch((e) => {
          console.error(e)
          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, data } = message

          expect(type).toEqual('portal:wasm:sign')
          expect(data).toMatchObject(args)
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:wasm:signError',
                data: {
                  code: 1,
                  message: 'test',
                },
              },
            }),
          )
        })

      mpc
        .sign(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('checkSharesOnDevice', () => {
    it('should successfully return the shares on device', (done) => {
      jest
        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
        .mockImplementation((message: any, origin?) => {
          const { type, data } = message

          expect(type).toEqual('portal:checkSharesOnDevice')
          expect(data).toMatchObject({})
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:checkSharesOnDeviceResult',
                data: mockSharesOnDevice,
              },
            }),
          )
        })

      mpc
        .checkSharesOnDevice()
        .then((res) => {
          expect(res).toEqual(mockSharesOnDevice)
          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, data } = message

          expect(type).toEqual('portal:checkSharesOnDevice')
          expect(data).toMatchObject({})
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:checkSharesOnDeviceError',
                data: {
                  code: 1,
                  message: 'test',
                },
              },
            }),
          )
        })

      mpc
        .checkSharesOnDevice()
        .then(() => {
          expect(0).toEqual(1)
          done()
        })
        .catch((e) => {
          expect(e).toBeInstanceOf(PortalMpcError)
          expect(e.message).toEqual('test')
          expect(e.code).toEqual(1)
          done()
        })
    })
  })

  describe('getBalances', () => {
    const args = ['eip155:1']
    const res = mockBalances

    it('should successfully return the balances', (done) => {
      jest
        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
        .mockImplementation((message: any, origin?) => {
          const { type, data } = message

          expect(type).toEqual('portal:getBalances')
          expect(data).toMatchObject({ chainId: args[0] })
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:getBalancesResult',
                data: res,
              },
            }),
          )
        })

      mpc
        .getBalances(...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, data } = message

          expect(type).toEqual('portal:getBalances')
          expect(data).toMatchObject({ chainId: args[0] })
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:getBalancesError',
                data: {
                  code: 1,
                  message: 'test',
                },
              },
            }),
          )
        })

      mpc
        .getBalances(...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('getClient', () => {
    const res = mockClientResponse

    it('should successfully return the client', (done) => {
      jest
        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
        .mockImplementation((message: any, origin?) => {
          const { type, data } = message

          expect(type).toEqual('portal:getClient')
          expect(data).toMatchObject({})
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:getClientResult',
                data: res,
              },
            }),
          )
        })

      mpc
        .getClient()
        .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, data } = message

          expect(type).toEqual('portal:getClient')
          expect(data).toMatchObject({})
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:getClientError',
                data: {
                  code: 1,
                  message: 'test',
                },
              },
            }),
          )
        })

      mpc
        .getClient()
        .then(() => {
          expect(0).toEqual(1)
          done()
        })
        .catch((e) => {
          expect(e).toBeInstanceOf(PortalMpcError)
          expect(e.message).toEqual('test')
          expect(e.code).toEqual(1)
          done()
        })
    })
  })

  describe('getNFTs', () => {
    const args = ['eip155:1']
    const res = mockNFTs

    it('should successfully return the nfts', (done) => {
      jest
        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
        .mockImplementation((message: any, origin?) => {
          const { type, data } = message

          expect(type).toEqual('portal:getNFTs')
          expect(data).toMatchObject({ chainId: args[0] })
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:getNFTsResult',
                data: res,
              },
            }),
          )
        })

      mpc
        .getNFTs(...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, data } = message

          expect(type).toEqual('portal:getNFTs')
          expect(data).toMatchObject({ chainId: args[0] })
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:getNFTsError',
                data: {
                  code: 1,
                  message: 'test',
                },
              },
            }),
          )
        })

      mpc
        .getNFTs(...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('getNFTAssets', () => {
    const args = ['eip155:1']
    const res = mockNFTs

    it('should successfully return the nfts', (done) => {
      jest
        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
        .mockImplementation((message: any, origin?) => {
          const { type, data } = message

          expect(type).toEqual('portal:getNFTAssets')
          expect(data).toMatchObject({ chainId: args[0] })
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:getNFTAssetsResult',
                data: res,
              },
            }),
          )
        })

      mpc
        .getNFTAssets(args[0])
        .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, data } = message

          expect(type).toEqual('portal:getNFTAssets')
          expect(data).toMatchObject({ chainId: args[0] })
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:getNFTAssetsError',
                data: {
                  code: 1,
                  message: 'test',
                },
              },
            }),
          )
        })

      mpc
        .getNFTAssets(args[0])
        .then(() => {
          expect(0).toEqual(1)
          done()
        })
        .catch((e) => {
          expect(e).toBeInstanceOf(PortalMpcError)
          expect(e.message).toEqual('test')
          expect(e.code).toEqual(1)
          done()
        })
    })
  })

  describe('getAssets', () => {
    const res = mockAssets

    it('should successfully return the assets', (done) => {
      jest
        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
        .mockImplementation((message: any, origin?) => {
          const { type, data } = message

          expect(type).toEqual('portal:getAssets')
          expect(data).toMatchObject({ chainId: 'eip155:1', includeNfts: true })
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:getAssetsResult',
                data: res,
              },
            }),
          )
        })

      mpc
        .getAssets('eip155:1', true)
        .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, data } = message

          expect(type).toEqual('portal:getAssets')
          expect(data).toMatchObject({ chainId: 'eip155:1', includeNfts: true })
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:getAssetsError',
                data: {
                  code: 1,
                  message: 'test',
                },
              },
            }),
          )
        })

      mpc
        .getAssets('eip155:1', true)
        .then(() => {
          expect(0).toEqual(1)
          done()
        })
        .catch((e) => {
          expect(e).toBeInstanceOf(PortalMpcError)
          expect(e.message).toEqual('test')
          expect(e.code).toEqual(1)
          done()
        })
    })
  })

  describe('buildTransaction', () => {
    const res = mockBuiltTransaction

    it('should successfully return the built transaction', (done) => {
      jest
        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
        .mockImplementation((message: any, origin?) => {
          const { type, data } = message

          expect(type).toEqual('portal:buildTransaction')
          expect(data).toMatchObject({
            chainId: 'eip155:1',
            to: mockAddress,
            token: 'USDT',
            amount: '42',
          })
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:buildTransactionResult',
                data: res,
              },
            }),
          )
        })

      mpc
        .buildTransaction('eip155:1', mockAddress, 'USDT', '42')
        .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, data } = message

          expect(type).toEqual('portal:buildTransaction')
          expect(data).toMatchObject({
            chainId: 'eip155:1',
            to: mockAddress,
            token: 'USDT',
            amount: '42',
          })
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:buildTransactionError',
                data: {
                  code: 1,
                  message: 'test',
                },
              },
            }),
          )
        })

      mpc
        .buildTransaction('eip155:1', mockAddress, 'USDT', '42')
        .then(() => {
          expect(0).toEqual(1)
          done()
        })
        .catch((e) => {
          expect(e).toBeInstanceOf(PortalMpcError)
          expect(e.message).toEqual('test')
          expect(e.code).toEqual(1)
          done()
        })
    })
  })

  describe('getQuote', () => {
    const res = mockBuiltTransaction

    it('should successfully return the quote', (done) => {
      jest
        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
        .mockImplementation((message: any, origin?) => {
          const { type, data } = message

          expect(type).toEqual('portal:swaps:getQuote')
          expect(data).toMatchObject({
            apiKey: mockApikey,
            args: mockQuoteArgs,
            chainId: 'eip155:1',
          })
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:swaps:getQuoteResult',
                data: res,
              },
            }),
          )
        })

      mpc
        .getQuote('eip155:1', mockQuoteArgs, mockApikey)
        .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, data } = message

          expect(type).toEqual('portal:swaps:getQuote')
          expect(data).toMatchObject({
            apiKey: mockApikey,
            args: mockQuoteArgs,
            chainId: 'eip155:1',
          })
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:swaps:getQuoteError',
                data: {
                  code: 1,
                  message: 'test',
                },
              },
            }),
          )
        })

      mpc
        .getQuote('eip155:1', mockQuoteArgs, mockApikey)
        .then(() => {
          expect(0).toEqual(1)
          done()
        })
        .catch((e) => {
          expect(e).toBeInstanceOf(PortalMpcError)
          expect(e.message).toEqual('test')
          expect(e.code).toEqual(1)
          done()
        })
    })
  })

  describe('getSources', () => {
    const res = mockBuiltTransaction

    it('should successfully return the sources', (done) => {
      jest
        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
        .mockImplementation((message: any, origin?) => {
          const { type, data } = message

          expect(type).toEqual('portal:swaps:getSources')
          expect(data).toMatchObject({ apiKey: mockApikey, chainId: 'eip155:1' })
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:swaps:getSourcesResult',
                data: res,
              },
            }),
          )
        })

      mpc
        .getSources('eip155:1', mockApikey)
        .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, data } = message

          expect(type).toEqual('portal:swaps:getSources')
          expect(data).toMatchObject({ apiKey: mockApikey, chainId: 'eip155:1' })
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:swaps:getSourcesError',
                data: {
                  code: 1,
                  message: 'test',
                },
              },
            }),
          )
        })

      mpc
        .getSources('eip155:1', mockApikey)
        .then(() => {
          expect(0).toEqual(1)
          done()
        })
        .catch((e) => {
          expect(e).toBeInstanceOf(PortalMpcError)
          expect(e.message).toEqual('test')
          expect(e.code).toEqual(1)
          done()
        })
    })
  })

  describe('getTransactions', () => {
    const res = mockBuiltTransaction

    it('should successfully return the transactions', (done) => {
      jest
        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
        .mockImplementation((message: any, origin?) => {
          const { type, data } = message

          expect(type).toEqual('portal:getTransactions')
          expect(data).toMatchObject({
            chainId: 'eip155:1',
            limit: undefined,
            offset: undefined,
            order: undefined,
          })
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:getTransactionsResult',
                data: res,
              },
            }),
          )
        })

      mpc
        .getTransactions('eip155:1')
        .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, data } = message

          expect(type).toEqual('portal:getTransactions')
          expect(data).toMatchObject({
            chainId: 'eip155:1',
            limit: undefined,
            offset: undefined,
            order: undefined,
          })
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:getTransactionsError',
                data: {
                  code: 1,
                  message: 'test',
                },
              },
            }),
          )
        })

      mpc
        .getTransactions('eip155:1')
        .then(() => {
          expect(0).toEqual(1)
          done()
        })
        .catch((e) => {
          expect(e).toBeInstanceOf(PortalMpcError)
          expect(e.message).toEqual('test')
          expect(e.code).toEqual(1)
          done()
        })
    })
  })

  describe('setBackupStatus', () => {
    const res = true

    it('should successfully set the backup status', (done) => {
      jest
        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
        .mockImplementation((message: any, origin?) => {
          const { type, data } = message

          expect(type).toEqual('portal:api:setBackupStatus')
          expect(data).toMatchObject({
            backupIds: mockBackupIds,
            status: 'STORED_CLIENT_BACKUP_SHARE',
          })
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:api:setBackupStatusResult',
                data: res,
              },
            }),
          )
        })

      mpc
        .setBackupStatus('STORED_CLIENT_BACKUP_SHARE', mockBackupIds)
        .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, data } = message

          expect(type).toEqual('portal:api:setBackupStatus')
          expect(data).toMatchObject({
            backupIds: mockBackupIds,
            status: 'STORED_CLIENT_BACKUP_SHARE',
          })
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:api:setBackupStatusError',
                data: {
                  code: 1,
                  message: 'test',
                },
              },
            }),
          )
        })

      mpc
        .setBackupStatus('STORED_CLIENT_BACKUP_SHARE', mockBackupIds)
        .then(() => {
          expect(0).toEqual(1)
          done()
        })
        .catch((e) => {
          expect(e).toBeInstanceOf(PortalMpcError)
          expect(e.message).toEqual('test')
          expect(e.code).toEqual(1)
          done()
        })
    })
  })

  describe('simulateTransaction', () => {
    const res = mockSimulationResult

    it('should successfully return the simulated transaction', (done) => {
      jest
        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
        .mockImplementation((message: any, origin?) => {
          const { type, data } = message

          expect(type).toEqual('portal:simulateTransaction')
          expect(data).toMatchObject({
            chainId: 'eip155:1',
            transaction: mockTransactionToSimulate,
          })
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:simulateTransactionResult',
                data: res,
              },
            }),
          )
        })

      mpc
        .simulateTransaction(mockTransactionToSimulate, 'eip155:1')
        .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, data } = message

          expect(type).toEqual('portal:simulateTransaction')
          expect(data).toMatchObject({
            chainId: 'eip155:1',
            transaction: mockTransactionToSimulate,
          })
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:simulateTransactionError',
                data: {
                  code: 1,
                  message: 'test',
                },
              },
            }),
          )
        })

      mpc
        .simulateTransaction(mockTransactionToSimulate, 'eip155:1')
        .then(() => {
          expect(0).toEqual(1)
          done()
        })
        .catch((e) => {
          expect(e).toBeInstanceOf(PortalMpcError)
          expect(e.message).toEqual('test')
          expect(e.code).toEqual(1)
          done()
        })
    })
  })

  describe('evaluateTransaction', () => {
    const res = mockEvaluationResult

    it('should successfully return the evaluated transaction', (done) => {
      jest
        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
        .mockImplementation((message: any, origin?) => {
          const { type, data } = message

          expect(type).toEqual('portal:evaluateTransaction')
          expect(data).toMatchObject({
            chainId: 'eip155:1',
            transaction: mockTransactionToEvaluate,
            operationType: 'all',
          })
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:evaluateTransactionResult',
                data: res,
              },
            }),
          )
        })

      mpc
        .evaluateTransaction('eip155:1', mockTransactionToEvaluate, 'all')
        .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, data } = message

          expect(type).toEqual('portal:evaluateTransaction')
          expect(data).toMatchObject({
            chainId: 'eip155:1',
            transaction: mockTransactionToEvaluate,
            operationType: 'all',
          })
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:evaluateTransactionError',
                data: {
                  code: 1,
                  message: 'test',
                },
              },
            }),
          )
        })

      mpc
        .evaluateTransaction('eip155:1', mockTransactionToEvaluate, 'all')
        .then(() => {
          expect(0).toEqual(1)
          done()
        })
        .catch((e) => {
          expect(e).toBeInstanceOf(PortalMpcError)
          expect(e.message).toEqual('test')
          expect(e.code).toEqual(1)
          done()
        })
    })
  })

  describe('storedClientBackupShare', () => {
    it('should successfully return the stored client backup share', (done) => {
      jest
        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
        .mockImplementation((message: any, origin?) => {
          const { type, data } = message

          expect(type).toEqual('portal:storedClientBackupShare')
          expect(data).toMatchObject({
            success: true,
            backupMethod: BackupMethods.password,
          })
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:storedClientBackupShareResult',
                data: true,
              },
            }),
          )
        })

      mpc
        .storedClientBackupShare(true, BackupMethods.password)
        .then((data) => {
          expect(data).toEqual(undefined)
          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, data } = message

          expect(type).toEqual('portal:storedClientBackupShare')
          expect(data).toMatchObject({
            success: true,
            backupMethod: BackupMethods.password,
          })
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:storedClientBackupShareError',
                data: {
                  code: 1,
                  message: 'test',
                },
              },
            }),
          )
        })

      mpc
        .storedClientBackupShare(true, BackupMethods.password)
        .then(() => {
          expect(0).toEqual(1)
          done()
        })
        .catch((e) => {
          expect(e).toBeInstanceOf(PortalMpcError)
          expect(e.message).toEqual('test')
          expect(e.code).toEqual(1)
          done()
        })
    })
  })

  describe('getYieldXyzYields', () => {
    const args = mockYieldXyzGetYieldsRequest
    const res = mockYieldXyzGetYieldsResponse

    it('should successfully return the yields', (done) => {
      jest
        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
        .mockImplementation((message: any, origin?) => {
          const { type, data } = message

          expect(type).toEqual('portal:yieldxyz:discover')
          expect(data).toMatchObject(args)
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:yieldxyz:discoverResult',
                data: res,
              },
            }),
          )
        })

      mpc
        .getYieldXyzYields(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, data } = message

          expect(type).toEqual('portal:yieldxyz:discover')
          expect(data).toMatchObject(args)
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:yieldxyz:discoverError',
                data: {
                  code: 1,
                  message: 'test',
                },
              },
            }),
          )
        })

      mpc
        .getYieldXyzYields(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('enterYieldXyzYield', () => {
    const args = mockYieldXyzEnterRequest
    const res = mockYieldXyzEnterResponse

    it('should successfully enter the yield', (done) => {
      jest
        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
        .mockImplementation((message: any, origin?) => {
          const { type, data } = message

          expect(type).toEqual('portal:yieldxyz:enter')
          expect(data).toMatchObject(args)
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:yieldxyz:enterResult',
                data: res,
              },
            }),
          )
        })

      mpc
        .enterYieldXyzYield(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, data } = message

          expect(type).toEqual('portal:yieldxyz:enter')
          expect(data).toMatchObject(args)
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:yieldxyz:enterError',
                data: {
                  code: 1,
                  message: 'test',
                },
              },
            }),
          )
        })

      mpc
        .enterYieldXyzYield(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('exitYieldXyzYield', () => {
    const args = mockYieldXyzExitRequest
    const res = mockYieldXyzExitResponse

    it('should successfully exit the yield', (done) => {
      jest
        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
        .mockImplementation((message: any, origin?) => {
          const { type, data } = message

          expect(type).toEqual('portal:yieldxyz:exit')
          expect(data).toMatchObject(args)
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:yieldxyz:exitResult',
                data: res,
              },
            }),
          )
        })

      mpc
        .exitYieldXyzYield(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, data } = message

          expect(type).toEqual('portal:yieldxyz:exit')
          expect(data).toMatchObject(args)
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:yieldxyz:exitError',
                data: {
                  code: 1,
                  message: 'test',
                },
              },
            }),
          )
        })

      mpc
        .exitYieldXyzYield(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('getYieldXyzBalances', () => {
    const args = mockYieldXyzGetBalancesRequest
    const res = mockYieldXyzGetBalancesResponse

    it('should successfully return the balances', (done) => {
      jest
        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
        .mockImplementation((message: any, origin?) => {
          const { type, data } = message

          expect(type).toEqual('portal:yieldxyz:getBalances')
          expect(data).toMatchObject(args)
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:yieldxyz:getBalancesResult',
                data: res,
              },
            }),
          )
        })

      mpc
        .getYieldXyzBalances(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, data } = message

          expect(type).toEqual('portal:yieldxyz:getBalances')
          expect(data).toMatchObject(args)
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:yieldxyz:getBalancesError',
                data: {
                  code: 1,
                  message: 'test',
                },
              },
            }),
          )
        })

      mpc
        .getYieldXyzBalances(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('getYieldXyzHistoricalActions', () => {
    const args = mockYieldXyzGetHistoricalActionsRequest
    const res = mockYieldXyzGetHistoricalActionsResponse

    it('should successfully return the historical actions', (done) => {
      jest
        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
        .mockImplementation((message: any, origin?) => {
          const { type, data } = message

          expect(type).toEqual('portal:yieldxyz:getHistoricalActions')
          expect(data).toMatchObject(args)
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:yieldxyz:getHistoricalActionsResult',
                data: res,
              },
            }),
          )
        })

      mpc
        .getYieldXyzHistoricalActions(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, data } = message

          expect(type).toEqual('portal:yieldxyz:getHistoricalActions')
          expect(data).toMatchObject(args)
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:yieldxyz:getHistoricalActionsError',
                data: {
                  code: 1,
                  message: 'test',
                },
              },
            }),
          )
        })

      mpc
        .getYieldXyzHistoricalActions(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('manageYieldXyzYield', () => {
    const args = mockYieldXyzManageYieldRequest
    const res = mockYieldXyzManageYieldResponse

    it('should successfully manage the yield', (done) => {
      jest
        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
        .mockImplementation((message: any, origin?) => {
          const { type, data } = message

          expect(type).toEqual('portal:yieldxyz:manage')
          expect(data).toMatchObject(args)
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:yieldxyz:manageYieldResult',
                data: res,
              },
            }),
          )
        })

      mpc
        .manageYieldXyzYield(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, data } = message

          expect(type).toEqual('portal:yieldxyz:manage')
          expect(data).toMatchObject(args)
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:yieldxyz:manageYieldError',
                data: {
                  code: 1,
                  message: 'test',
                },
              },
            }),
          )
        })

      mpc
        .manageYieldXyzYield(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('trackYieldXyzTransaction', () => {
    const args = mockYieldXyzTrackTransactionRequest
    const res = mockYieldXyzTrackTransactionResponse

    it('should successfully track the transaction', (done) => {
      jest
        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
        .mockImplementation((message: any, origin?) => {
          const { type, data } = message

          expect(type).toEqual('portal:yieldxyz:track')
          expect(data).toMatchObject(args)
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:yieldxyz:trackResult',
                data: res,
              },
            }),
          )
        })

      mpc
        .trackYieldXyzTransaction(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, data } = message

          expect(type).toEqual('portal:yieldxyz:track')
          expect(data).toMatchObject(args)
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:yieldxyz:trackError',
                data: {
                  code: 1,
                  message: 'test',
                },
              },
            }),
          )
        })

      mpc
        .trackYieldXyzTransaction(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('getYieldXyzTransaction', () => {
    const args = 'test-tx-id'
    const res = mockYieldXyzGetTransactionResponse

    it('should successfully return the transaction', (done) => {
      jest
        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
        .mockImplementation((message: any, origin?) => {
          const { type, data } = message

          expect(type).toEqual('portal:yieldxyz:getTransaction')
          expect(data).toEqual(args)
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:yieldxyz:getTransactionResult',
                data: res,
              },
            }),
          )
        })

      mpc
        .getYieldXyzTransaction(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, data } = message

          expect(type).toEqual('portal:yieldxyz:getTransaction')
          expect(data).toEqual(args)
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:yieldxyz:getTransactionError',
                data: {
                  code: 1,
                  message: 'test',
                },
              },
            }),
          )
        })

      mpc
        .getYieldXyzTransaction(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('getLifiRoutes', () => {
    const args = mockLifiGetRoutesRequest
    const res = mockLifiGetRoutesResponse

    it('should successfully return the routes', (done) => {
      jest
        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
        .mockImplementation((message: any, origin?) => {
          const { type, data } = message

          expect(type).toEqual('portal:lifi:getRoutes')
          expect(data).toMatchObject(args)
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:lifi:getRoutesResult',
                data: res,
              },
            }),
          )
        })

      mpc
        .getLifiRoutes(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, data } = message

          expect(type).toEqual('portal:lifi:getRoutes')
          expect(data).toMatchObject(args)
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:lifi:getRoutesError',
                data: {
                  code: 1,
                  message: 'test',
                },
              },
            }),
          )
        })

      mpc
        .getLifiRoutes(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('getLifiQuote', () => {
    const args = mockLifiGetQuoteRequest
    const res = mockLifiGetQuoteResponse

    it('should successfully return the quote', (done) => {
      jest
        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
        .mockImplementation((message: any, origin?) => {
          const { type, data } = message

          expect(type).toEqual('portal:lifi:getQuote')
          expect(data).toMatchObject(args)
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:lifi:getQuoteResult',
                data: res,
              },
            }),
          )
        })

      mpc
        .getLifiQuote(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, data } = message

          expect(type).toEqual('portal:lifi:getQuote')
          expect(data).toMatchObject(args)
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:lifi:getQuoteError',
                data: {
                  code: 1,
                  message: 'test',
                },
              },
            }),
          )
        })

      mpc
        .getLifiQuote(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('getLifiStatus', () => {
    const args = mockLifiGetStatusRequest
    const res = mockLifiGetStatusResponse

    it('should successfully return the status', (done) => {
      jest
        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
        .mockImplementation((message: any, origin?) => {
          const { type, data } = message

          expect(type).toEqual('portal:lifi:getStatus')
          expect(data).toMatchObject(args)
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:lifi:getStatusResult',
                data: res,
              },
            }),
          )
        })

      mpc
        .getLifiStatus(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, data } = message

          expect(type).toEqual('portal:lifi:getStatus')
          expect(data).toMatchObject(args)
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:lifi:getStatusError',
                data: {
                  code: 1,
                  message: 'test',
                },
              },
            }),
          )
        })

      mpc
        .getLifiStatus(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('getLifiRouteStep', () => {
    const args = mockLifiGetRouteStepRequest
    const res = mockLifiGetRouteStepResponse

    it('should successfully return the route step', (done) => {
      jest
        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
        .mockImplementation((message: any, origin?) => {
          const { type, data } = message

          expect(type).toEqual('portal:lifi:getRouteStep')
          expect(data).toMatchObject(args)
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:lifi:getRouteStepResult',
                data: res,
              },
            }),
          )
        })

      mpc
        .getLifiRouteStep(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, data } = message

          expect(type).toEqual('portal:lifi:getRouteStep')
          expect(data).toMatchObject(args)
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:lifi:getRouteStepError',
                data: {
                  code: 1,
                  message: 'test',
                },
              },
            }),
          )
        })

      mpc
        .getLifiRouteStep(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('getSwapsQuoteV2', () => {
    const args = mockZeroExQuoteV2Request
    const options = mockZeroExOptions
    const res = mockZeroExQuoteV2Response

    it('should successfully return the quote', (done) => {
      jest
        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
        .mockImplementation((message: any, origin?) => {
          const { type, data } = message

          expect(type).toEqual('portal:swaps:getQuoteV2')
          expect(data).toMatchObject({ ...args, options })
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:swaps:getQuoteV2Result',
                data: res,
              },
            }),
          )
        })

      mpc
        .getSwapsQuoteV2(args, options)
        .then((data) => {
          expect(data).toEqual(res)
          done()
        })
        .catch((_) => {
          expect(0).toEqual(1)
          done()
        })
    })

    it('should successfully return the quote without options', (done) => {
      jest
        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
        .mockImplementation((message: any, origin?) => {
          const { type, data } = message

          expect(type).toEqual('portal:swaps:getQuoteV2')
          expect(data).toMatchObject({ ...args, options: undefined })
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:swaps:getQuoteV2Result',
                data: res,
              },
            }),
          )
        })

      mpc
        .getSwapsQuoteV2(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, data } = message

          expect(type).toEqual('portal:swaps:getQuoteV2')
          expect(data).toMatchObject({ ...args, options })
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:swaps:getQuoteV2Error',
                data: {
                  code: 1,
                  message: 'test',
                },
              },
            }),
          )
        })

      mpc
        .getSwapsQuoteV2(args, options)
        .then(() => {
          expect(0).toEqual(1)
          done()
        })
        .catch((e) => {
          expect(e).toBeInstanceOf(PortalMpcError)
          expect(e.message).toEqual('test')
          expect(e.code).toEqual(1)
          done()
        })
    })
  })

  describe('getSwapsSourcesV2', () => {
    const args = mockZeroExSourcesV2Request
    const options = mockZeroExOptions
    const res = mockZeroExSourcesV2Response

    it('should successfully return the sources', (done) => {
      jest
        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
        .mockImplementation((message: any, origin?) => {
          const { type, data } = message

          expect(type).toEqual('portal:swaps:getSourcesV2')
          expect(data).toMatchObject({ ...args, options })
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:swaps:getSourcesV2Result',
                data: res,
              },
            }),
          )
        })

      mpc
        .getSwapsSourcesV2(args, options)
        .then((data) => {
          expect(data).toEqual(res)
          done()
        })
        .catch((_) => {
          expect(0).toEqual(1)
          done()
        })
    })

    it('should successfully return the sources without options', (done) => {
      jest
        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
        .mockImplementation((message: any, origin?) => {
          const { type, data } = message

          expect(type).toEqual('portal:swaps:getSourcesV2')
          expect(data).toMatchObject({ ...args, options: undefined })
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:swaps:getSourcesV2Result',
                data: res,
              },
            }),
          )
        })

      mpc
        .getSwapsSourcesV2(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, data } = message

          expect(type).toEqual('portal:swaps:getSourcesV2')
          expect(data).toMatchObject({ ...args, options })
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:swaps:getSourcesV2Error',
                data: {
                  code: 1,
                  message: 'test',
                },
              },
            }),
          )
        })

      mpc
        .getSwapsSourcesV2(args, options)
        .then(() => {
          expect(0).toEqual(1)
          done()
        })
        .catch((e) => {
          expect(e).toBeInstanceOf(PortalMpcError)
          expect(e.message).toEqual('test')
          expect(e.code).toEqual(1)
          done()
        })
    })
  })

  describe('getSwapsPrice', () => {
    const args = mockZeroExPriceRequest
    const options = mockZeroExOptions
    const res = mockZeroExPriceResponse

    it('should successfully return the price', (done) => {
      jest
        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
        .mockImplementation((message: any, origin?) => {
          const { type, data } = message

          expect(type).toEqual('portal:swaps:getPrice')
          expect(data).toMatchObject({ ...args, options })
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:swaps:getPriceResult',
                data: res,
              },
            }),
          )
        })

      mpc
        .getSwapsPrice(args, options)
        .then((data) => {
          expect(data).toEqual(res)
          done()
        })
        .catch((_) => {
          expect(0).toEqual(1)
          done()
        })
    })

    it('should successfully return the price without options', (done) => {
      jest
        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
        .mockImplementation((message: any, origin?) => {
          const { type, data } = message

          expect(type).toEqual('portal:swaps:getPrice')
          expect(data).toMatchObject({ ...args, options: undefined })
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:swaps:getPriceResult',
                data: res,
              },
            }),
          )
        })

      mpc
        .getSwapsPrice(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, data } = message

          expect(type).toEqual('portal:swaps:getPrice')
          expect(data).toMatchObject({ ...args, options })
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:swaps:getPriceError',
                data: {
                  code: 1,
                  message: 'test',
                },
              },
            }),
          )
        })

      mpc
        .getSwapsPrice(args, options)
        .then(() => {
          expect(0).toEqual(1)
          done()
        })
        .catch((e) => {
          expect(e).toBeInstanceOf(PortalMpcError)
          expect(e.message).toEqual('test')
          expect(e.code).toEqual(1)
          done()
        })
    })
  })

  describe('scanAddresses', () => {
    const args = mockScanAddressesRequest
    const res = mockScanAddressesResponse

    it('should successfully scan addresses', (done) => {
      jest
        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
        .mockImplementation((message: any, origin?) => {
          const { type, data } = message

          expect(type).toEqual('portal:security:scanAddresses')
          expect(data).toMatchObject(args)
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:security:scanAddressesResult',
                data: res,
              },
            }),
          )
        })

      mpc
        .scanAddresses(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, data } = message

          expect(type).toEqual('portal:security:scanAddresses')
          expect(data).toMatchObject(args)
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:security:scanAddressesError',
                data: {
                  code: 1,
                  message: 'test',
                },
              },
            }),
          )
        })

      mpc
        .scanAddresses(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('scanEVMTx', () => {
    const args = mockScanEVMTxRequest
    const res = mockScanEVMTxResponse

    it('should successfully scan EIP-155 transaction', (done) => {
      jest
        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
        .mockImplementation((message: any, origin?) => {
          const { type, data } = message

          expect(type).toEqual('portal:security:scanEVMTx')
          expect(data).toMatchObject(args)
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:security:scanEVMTxResult',
                data: res,
              },
            }),
          )
        })

      mpc
        .scanEVMTx(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, data } = message

          expect(type).toEqual('portal:security:scanEVMTx')
          expect(data).toMatchObject(args)
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:security:scanEVMTxError',
                data: {
                  code: 1,
                  message: 'test',
                },
              },
            }),
          )
        })

      mpc
        .scanEVMTx(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('scanEip712Tx', () => {
    const args = mockScanEip712TxRequest
    const res = mockScanEip712TxResponse

    it('should successfully scan EIP-712 transaction', (done) => {
      jest
        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
        .mockImplementation((message: any, origin?) => {
          const { type, data } = message

          expect(type).toEqual('portal:security:scanEip712Tx')
          expect(data).toMatchObject(args)
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:security:scanEip712TxResult',
                data: res,
              },
            }),
          )
        })

      mpc
        .scanEip712Tx(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, data } = message

          expect(type).toEqual('portal:security:scanEip712Tx')
          expect(data).toMatchObject(args)
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:security:scanEip712TxError',
                data: {
                  code: 1,
                  message: 'test',
                },
              },
            }),
          )
        })

      mpc
        .scanEip712Tx(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('scanSolanaTx', () => {
    const args = mockScanSolanaTxRequest
    const res = mockScanSolanaTxResponse

    it('should successfully scan Solana transaction', (done) => {
      jest
        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
        .mockImplementation((message: any, origin?) => {
          const { type, data } = message

          expect(type).toEqual('portal:security:scanSolanaTx')
          expect(data).toMatchObject(args)
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:security:scanSolanaTxResult',
                data: res,
              },
            }),
          )
        })

      mpc
        .scanSolanaTx(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, data } = message

          expect(type).toEqual('portal:security:scanSolanaTx')
          expect(data).toMatchObject(args)
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:security:scanSolanaTxError',
                data: {
                  code: 1,
                  message: 'test',
                },
              },
            }),
          )
        })

      mpc
        .scanSolanaTx(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('scanNft', () => {
    const args = mockScanNftRequest
    const res = mockScanNftResponse

    it('should successfully scan NFT', (done) => {
      jest
        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
        .mockImplementation((message: any, origin?) => {
          const { type, data } = message

          expect(type).toEqual('portal:security:scanNfts')
          expect(data).toMatchObject(args)
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:security:scanNftsResult',
                data: res,
              },
            }),
          )
        })

      mpc
        .scanNFTs(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, data } = message

          expect(type).toEqual('portal:security:scanNfts')
          expect(data).toMatchObject(args)
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:security:scanNftsError',
                data: {
                  code: 1,
                  message: 'test',
                },
              },
            }),
          )
        })

      mpc
        .scanNFTs(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('scanToken', () => {
    const args = mockScanTokenRequest
    const res = mockScanTokenResponse

    it('should successfully scan token', (done) => {
      jest
        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
        .mockImplementation((message: any, origin?) => {
          const { type, data } = message

          expect(type).toEqual('portal:security:scanTokens')
          expect(data).toMatchObject(args)
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:security:scanTokensResult',
                data: res,
              },
            }),
          )
        })

      mpc
        .scanTokens(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, data } = message

          expect(type).toEqual('portal:security:scanTokens')
          expect(data).toMatchObject(args)
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:security:scanTokensError',
                data: {
                  code: 1,
                  message: 'test',
                },
              },
            }),
          )
        })

      mpc
        .scanTokens(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('scanUrl', () => {
    const args = mockScanUrlRequest
    const res = mockScanUrlResponse

    it('should successfully scan URL', (done) => {
      jest
        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
        .mockImplementation((message: any, origin?) => {
          const { type, data } = message

          expect(type).toEqual('portal:security:scanUrl')
          expect(data).toMatchObject({ url: args })
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:security:scanUrlResult',
                data: res,
              },
            }),
          )
        })

      mpc
        .scanUrl(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, data } = message

          expect(type).toEqual('portal:security:scanUrl')
          expect(data).toMatchObject({ url: args })
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:security:scanUrlError',
                data: {
                  code: 1,
                  message: 'test',
                },
              },
            }),
          )
        })

      mpc
        .scanUrl(args)
        .then(() => {
          expect(0).toEqual(1)
          done()
        })
        .catch((e) => {
          expect(e).toBeInstanceOf(PortalMpcError)
          expect(e.message).toEqual('test')
          expect(e.code).toEqual(1)
          done()
        })
    })
  })

  /*******************************
   * Blockaid Security Methods Tests
   *******************************/

  describe('blockaidScanEvmTx', () => {
    const args = mockBlockaidScanEvmTxRequest
    const res = mockBlockaidScanEvmTxResponse

    it('should successfully scan EVM transaction with Blockaid', (done) => {
      jest
        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
        .mockImplementation((message: any, origin?) => {
          const { type, data } = message

          expect(type).toEqual('portal:blockaid:scanEvmTx')
          expect(data).toMatchObject(args)
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:blockaid:scanEvmTxResult',
                data: res,
              },
            }),
          )
        })

      mpc
        .blockaidScanEvmTx(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, data } = message

          expect(type).toEqual('portal:blockaid:scanEvmTx')
          expect(data).toMatchObject(args)
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:blockaid:scanEvmTxError',
                data: {
                  code: 1,
                  message: 'test',
                },
              },
            }),
          )
        })

      mpc
        .blockaidScanEvmTx(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('blockaidScanSolanaTx', () => {
    const args = mockBlockaidScanSolanaTxRequest
    const res = mockBlockaidScanSolanaTxResponse

    it('should successfully scan Solana transaction with Blockaid', (done) => {
      jest
        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
        .mockImplementation((message: any, origin?) => {
          const { type, data } = message

          expect(type).toEqual('portal:blockaid:scanSolanaTx')
          expect(data).toMatchObject(args)
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:blockaid:scanSolanaTxResult',
                data: res,
              },
            }),
          )
        })

      mpc
        .blockaidScanSolanaTx(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, data } = message

          expect(type).toEqual('portal:blockaid:scanSolanaTx')
          expect(data).toMatchObject(args)
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:blockaid:scanSolanaTxError',
                data: {
                  code: 1,
                  message: 'test',
                },
              },
            }),
          )
        })

      mpc
        .blockaidScanSolanaTx(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('blockaidScanAddress', () => {
    const args = mockBlockaidScanAddressRequest
    const res = mockBlockaidScanAddressResponse

    it('should successfully scan address with Blockaid', (done) => {
      jest
        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
        .mockImplementation((message: any, origin?) => {
          const { type, data } = message

          expect(type).toEqual('portal:blockaid:scanAddress')
          expect(data).toMatchObject(args)
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:blockaid:scanAddressResult',
                data: res,
              },
            }),
          )
        })

      mpc
        .blockaidScanAddress(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, data } = message

          expect(type).toEqual('portal:blockaid:scanAddress')
          expect(data).toMatchObject(args)
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:blockaid:scanAddressError',
                data: {
                  code: 1,
                  message: 'test',
                },
              },
            }),
          )
        })

      mpc
        .blockaidScanAddress(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('blockaidScanTokens', () => {
    const args = mockBlockaidScanTokensRequest
    const res = mockBlockaidScanTokensResponse

    it('should successfully scan tokens with Blockaid', (done) => {
      jest
        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
        .mockImplementation((message: any, origin?) => {
          const { type, data } = message

          expect(type).toEqual('portal:blockaid:scanTokens')
          expect(data).toMatchObject(args)
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:blockaid:scanTokensResult',
                data: res,
              },
            }),
          )
        })

      mpc
        .blockaidScanTokens(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, data } = message

          expect(type).toEqual('portal:blockaid:scanTokens')
          expect(data).toMatchObject(args)
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:blockaid:scanTokensError',
                data: {
                  code: 1,
                  message: 'test',
                },
              },
            }),
          )
        })

      mpc
        .blockaidScanTokens(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('blockaidScanUrl', () => {
    const args = mockBlockaidScanUrlRequest
    const res = mockBlockaidScanUrlResponse

    it('should successfully scan URL with Blockaid', (done) => {
      jest
        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
        .mockImplementation((message: any, origin?) => {
          const { type, data } = message

          expect(type).toEqual('portal:blockaid:scanUrl')
          expect(data).toMatchObject(args)
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:blockaid:scanUrlResult',
                data: res,
              },
            }),
          )
        })

      mpc
        .blockaidScanUrl(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, data } = message

          expect(type).toEqual('portal:blockaid:scanUrl')
          expect(data).toMatchObject(args)
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:blockaid:scanUrlError',
                data: {
                  code: 1,
                  message: 'test',
                },
              },
            }),
          )
        })

      mpc
        .blockaidScanUrl(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('accountAbstractionBuildBatchedUserOp', () => {
    const args = mockBuildBatchedUserOpRequest
    const res = mockBuildBatchedUserOpResponse

    it('should successfully build a user operation', (done) => {
      jest
        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
        .mockImplementation((message: any, origin?) => {
          const { type, data } = message

          expect(type).toEqual('portal:accountAbstraction:buildBatchedUserOp')
          expect(data).toMatchObject(args)
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:accountAbstraction:buildBatchedUserOpResult',
                data: res,
              },
            }),
          )
        })

      mpc
        .accountAbstractionBuildBatchedUserOp(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, data } = message

          expect(type).toEqual('portal:accountAbstraction:buildBatchedUserOp')
          expect(data).toMatchObject(args)
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:accountAbstraction:buildBatchedUserOpError',
                data: {
                  code: 1,
                  message: 'test',
                },
              },
            }),
          )
        })

      mpc
        .accountAbstractionBuildBatchedUserOp(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('accountAbstractionBroadcastBatchedUserOp', () => {
    const args = mockBroadcastBatchedUserOpRequest
    const res = mockBroadcastBatchedUserOpResponse

    it('should successfully broadcast a user operation', (done) => {
      jest
        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
        .mockImplementation((message: any, origin?) => {
          const { type, data } = message

          expect(type).toEqual(
            'portal:accountAbstraction:broadcastBatchedUserOp',
          )
          expect(data).toMatchObject(args)
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:accountAbstraction:broadcastBatchedUserOpResult',
                data: res,
              },
            }),
          )
        })

      mpc
        .accountAbstractionBroadcastBatchedUserOp(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, data } = message

          expect(type).toEqual(
            'portal:accountAbstraction:broadcastBatchedUserOp',
          )
          expect(data).toMatchObject(args)
          expect(typeof message.traceId).toBe('string')
          expect(origin).toEqual(mockHostOrigin)

          window.dispatchEvent(
            new MessageEvent('message', {
              origin: mockHostOrigin,
              data: {
                type: 'portal:accountAbstraction:broadcastBatchedUserOpError',
                data: {
                  code: 1,
                  message: 'test',
                },
              },
            }),
          )
        })

      mpc
        .accountAbstractionBroadcastBatchedUserOp(args)
        .then(() => {
          expect(0).toEqual(1)
          done()
        })
        .catch((e) => {
          expect(e).toBeInstanceOf(PortalMpcError)
          expect(e.message).toEqual('test')
          expect(e.code).toEqual(1)
          done()
        })
    })
  })
})