wallet-stack 1.0.0-alpha.121

package/src/redux/migrations.test.ts

@@ -0,0 +1,1925 @@
+import BigNumber from 'bignumber.js'
+import _ from 'lodash'
+import {
+  FinclusiveKycStatus,
+  PincodeType,
+  RecoveryPhraseInOnboardingStatus,
+} from 'src/account/reducer'
+import { DEEP_LINK_URL_SCHEME, ONBOARDING_FEATURES_ENABLED } from 'src/config'
+import { Screens } from 'src/navigator/Screens'
+import { ToggleableOnboardingFeatures } from 'src/onboarding/types'
+import { exchangeInitialState, migrations } from 'src/redux/migrations'
+import {
+  Network,
+  NetworkId,
+  TokenTransactionTypeV2,
+  TransactionStatus,
+} from 'src/transactions/types'
+import { CiCoCurrency, Currency } from 'src/utils/currencies'
+import {
+  DEFAULT_DAILY_PAYMENT_LIMIT_CUSD_LEGACY,
+  v0Schema,
+  v103Schema,
+  v104Schema,
+  v106Schema,
+  v112Schema,
+  v115Schema,
+  v124Schema,
+  v125Schema,
+  v130Schema,
+  v132Schema,
+  v133Schema,
+  v136Schema,
+  v13Schema,
+  v144Schema,
+  v145Schema,
+  v146Schema,
+  v148Schema,
+  v14Schema,
+  v159Schema,
+  v15Schema,
+  v164Schema,
+  v166Schema,
+  v167Schema,
+  v16Schema,
+  v171Schema,
+  v172Schema,
+  v174Schema,
+  v176Schema,
+  v177Schema,
+  v178Schema,
+  v179Schema,
+  v17Schema,
+  v18Schema,
+  v197Schema,
+  v1Schema,
+  v200Schema,
+  v201Schema,
+  v203Schema,
+  v214Schema,
+  v216Schema,
+  v21Schema,
+  v222Schema,
+  v227Schema,
+  v228Schema,
+  v230Schema,
+  v233Schema,
+  v235Schema,
+  v251Schema,
+  v28Schema,
+  v2Schema,
+  v35Schema,
+  v36Schema,
+  v37Schema,
+  v41Schema,
+  v43Schema,
+  v45Schema,
+  v46Schema,
+  v49Schema,
+  v50Schema,
+  v51Schema,
+  v52Schema,
+  v53Schema,
+  v56Schema,
+  v57Schema,
+  v58Schema,
+  v59Schema,
+  v62Schema,
+  v75Schema,
+  v7Schema,
+  v81Schema,
+  v84Schema,
+  v8Schema,
+  v98Schema,
+  v99Schema,
+  vNeg1Schema,
+} from 'test/schemas'
+import {
+  mockEarnDepositTransaction,
+  mockInvitableRecipient,
+  mockInvitableRecipient2,
+  mockPositionsLegacy,
+  mockPositionsLegacy2,
+  mockRecipient,
+  mockRecipient2,
+  mockShortcuts,
+  mockShortcutsLegacy,
+} from 'test/values'
+
+describe('Redux persist migrations', () => {
+  beforeEach(() => {
+    jest.replaceProperty(
+      ONBOARDING_FEATURES_ENABLED,
+      ToggleableOnboardingFeatures.CloudBackup,
+      false
+    )
+    jest.replaceProperty(
+      ONBOARDING_FEATURES_ENABLED,
+      ToggleableOnboardingFeatures.PhoneVerification,
+      false
+    )
+  })
+  it('works for v-1 to v0', () => {
+    const mockNumber = '+111111111111'
+    const mockAddress = '0x00000000000000000000'
+    const vNeg1Stub = {
+      ...vNeg1Schema,
+      identity: {
+        ...vNeg1Schema.identity,
+        e164NumberToAddress: { [mockNumber]: mockAddress },
+      },
+    }
+    const migratedSchema = migrations[0](vNeg1Stub)
+    expect(migratedSchema.identity.e164NumberToAddress).toEqual({ [mockNumber]: [mockAddress] })
+  })
+
+  it('works for v0 to v1', () => {
+    const mockNumber = '+111111111111'
+    const mockAddress = '0x00000000000000000000'
+    const v0Stub = {
+      ...v0Schema,
+      invite: {
+        ...v0Schema.invite,
+        invitees: {
+          [mockAddress]: mockNumber,
+        },
+      },
+    }
+    const migratedSchema = migrations[1](v0Stub)
+    expect(migratedSchema.invite.invitees[0].tempWalletAddress).toEqual(mockAddress)
+  })
+
+  it('works for v1 to v2', () => {
+    const v1Stub = {
+      ...v1Schema,
+      app: {
+        ...v1Schema.app,
+        numberVerified: true,
+      },
+    }
+    const migratedSchema = migrations[2](v1Stub)
+    expect(migratedSchema.app.numberVerified).toEqual(false)
+  })
+
+  it('works for v2 to v3', () => {
+    const v2Stub = {
+      ...v2Schema,
+      send: {
+        ...v2Schema.send,
+        recentPayments: [{ timestamp: Date.now(), amount: '100' }],
+      },
+      account: {
+        ...v2Schema.account,
+        hasMigratedToNewBip39: false,
+      },
+    }
+    const migratedSchema = migrations[3](v2Stub)
+    expect(migratedSchema.send.recentPayments.length).toEqual(0)
+  })
+
+  it('works for v3 to v4', () => {
+    const v3Stub = {
+      ...v2Schema,
+      identity: {
+        ...v2Schema.identity,
+        acceptedAttestationCodes: [{ code: 'code', issuer: 'issuer' }],
+      },
+    }
+    const migratedSchema = migrations[4](v3Stub)
+    expect(migratedSchema.identity.acceptedAttestationCodes.length).toEqual(0)
+  })
+
+  it('works for v4 to v5', () => {
+    const v4Stub = {
+      account: {
+        incomingPaymentRequests: [1, 2, 3],
+        outgoingPaymentRequests: [],
+      },
+      web3: {
+        commentKey: 'key',
+      },
+    }
+    const migratedSchema = migrations[5](v4Stub)
+    expect(migratedSchema.paymentRequest.incomingPaymentRequests).toMatchObject([1, 2, 3])
+    expect(migratedSchema.paymentRequest.outgoingPaymentRequests).toMatchObject([])
+    expect(migratedSchema.account.incomingPaymentRequests).toBe(undefined)
+    expect(migratedSchema.account.outgoingPaymentRequests).toBe(undefined)
+    expect(migratedSchema.web3.dataEncryptionKey).toBe('key')
+    expect(migratedSchema.web3.commentKey).toBe(undefined)
+  })
+
+  it('works for v5 to v6', () => {
+    const v5Stub = {
+      invite: {
+        redeemComplete: false,
+      },
+      web3: {
+        account: 'some_account',
+      },
+    }
+    const migratedSchema = migrations[6](v5Stub)
+    expect(migratedSchema.invite.redeemComplete).toBe(true)
+  })
+
+  it('works for v6 to v7', () => {
+    const mockAddress = '0x00000000000000000000'
+    const mockName = 'Mock Name'
+
+    const v6Stub = {
+      identity: {
+        addressToDisplayName: {
+          [mockAddress]: mockName,
+        },
+      },
+    }
+    const migratedSchema = migrations[7](v6Stub)
+    expect(Object.keys(migratedSchema.identity.addressToDisplayName).length).toEqual(1)
+    expect(migratedSchema.identity.addressToDisplayName[mockAddress].name).toEqual(mockName)
+    expect(migratedSchema.identity.addressToDisplayName[mockAddress].imageUrl).toBeNull()
+  })
+
+  it('works for v7 to v8', () => {
+    const txHash = '0x00000000000000000000'
+    const mockName = 'Mock Name'
+    const mockIcon = 'Mock icon'
+
+    const v7Stub = {
+      fiatExchanges: {
+        txHashToProvider: {
+          [txHash]: {
+            name: mockName,
+            icon: mockIcon,
+          },
+        },
+        lastUsedProvider: {
+          name: 'Simplex',
+          icon: mockIcon,
+        },
+      },
+    }
+    const migratedSchema = migrations[8](v7Stub)
+    expect(Object.keys(migratedSchema.fiatExchanges.txHashToProvider).length).toEqual(1)
+    expect(migratedSchema.fiatExchanges.txHashToProvider[txHash].name).toEqual(mockName)
+    expect(migratedSchema.fiatExchanges.txHashToProvider[txHash].icon).toEqual(mockIcon)
+    expect(migratedSchema.fiatExchanges.lastUsedProvider).toEqual('Simplex')
+  })
+
+  it('works for v8 to v9', () => {
+    const v8Stub = {
+      account: {
+        dailyLimitCusd: 500,
+      },
+    }
+    const migratedSchema = migrations[9](v8Stub)
+    expect(migratedSchema.account.dailyLimitCusd).toEqual(DEFAULT_DAILY_PAYMENT_LIMIT_CUSD_LEGACY)
+  })
+  it('works for v9 to v10', () => {
+    const v9Stub = v7Schema
+    const migratedSchema = migrations[10](v9Stub)
+    expect(migratedSchema.identity.feelessAttestationCodes).toBeUndefined()
+    expect(migratedSchema.identity.feelessProcessingInputCode).toBeUndefined()
+    expect(migratedSchema.identity.feelessAcceptedAttestationCodes).toBeUndefined()
+    expect(migratedSchema.identity.feelessNumCompleteAttestations).toBeUndefined()
+    expect(migratedSchema.identity.feelessVerificationStatus).toBeUndefined()
+    expect(migratedSchema.identity.verificationState).toBeUndefined()
+    expect(migratedSchema.identity.feelessVerificationState).toBeUndefined()
+    expect(migratedSchema.identity.feelessLastRevealAttempt).toBeUndefined()
+  })
+  it('works for v10 to v11', () => {
+    const migratedSchema = migrations[11](v8Schema)
+    expect(migratedSchema.app.pontoEnabled).toBeUndefined()
+    expect(migratedSchema.app.kotaniEnabled).toBeUndefined()
+    expect(migratedSchema.app.bitfyUrl).toBeUndefined()
+    expect(migratedSchema.app.flowBtcUrl).toBeUndefined()
+  })
+  it('works for v11 to v12', () => {
+    const appStub = 'dont delete please'
+    const exchangeStub = 'also dont delete please'
+    const stub = {
+      exchange: {
+        otherExchangeProps: exchangeStub,
+        history: {
+          celoGoldExchangeRates: [1, 2, 3],
+          aggregatedExchangeRates: [4, 5, 6],
+          granularity: 0,
+          range: 0,
+          lastTimeUpdated: 100,
+        },
+      },
+      app: appStub,
+    }
+    const migratedSchema = migrations[12](stub)
+    expect(migratedSchema.app).toEqual(appStub)
+    expect(migratedSchema.exchange.otherExchangeProps).toEqual(exchangeStub)
+    expect(migratedSchema.exchange.history).toEqual(exchangeInitialState.history)
+  })
+  it('works for v12 to v13', () => {
+    const stub = {
+      verify: {
+        existingProperty: 'verify_existingProperty',
+        TEMPORARY_override_withoutVerification: 'oldValue',
+        withoutRevealing: true,
+        retries: 3,
+      },
+      identity: {
+        existingProperty: 'identity_existingProperty',
+        hasSeenVerificationNux: true,
+        attestationCodes: ['code1', 'code2'],
+        acceptedAttestationCodes: ['code1'],
+        attestationInputStatus: ['loading'],
+        numCompleteAttestations: 3,
+        verificationStatus: 'verified',
+        lastRevealAttempt: 'yesterday',
+      },
+    }
+    const migratedSchema = migrations[13](stub)
+    expect(migratedSchema.verify.existingProperty).toEqual('verify_existingProperty')
+    expect(migratedSchema.identity.existingProperty).toEqual('identity_existingProperty')
+    expect(migratedSchema.verify.seenVerificationNux).toEqual(true)
+    const deletedIdentityProperties = [
+      'attestationCodes',
+      'acceptedAttestationCodes',
+      'attestationInputStatus',
+      'numCompleteAttestations',
+      'verificationStatus',
+      'lastRevealAttempt',
+    ]
+    for (const deletedProperty of deletedIdentityProperties) {
+      expect(Object.keys(migratedSchema.identity).includes(deletedProperty)).toEqual(false)
+    }
+    const deletedVerifyProperties = [
+      'TEMPORARY_override_withoutVerification',
+      'withoutRevealing',
+      'retries',
+    ]
+    for (const deletedProperty of deletedVerifyProperties) {
+      expect(Object.keys(migratedSchema.verify).includes(deletedProperty)).toEqual(false)
+    }
+  })
+
+  it('works for v13 to v14', () => {
+    const migratedSchema = migrations[14](v13Schema)
+    expect(migratedSchema.networkInfo.userLocationData).toBeDefined()
+    expect(migratedSchema.networkInfo.userLocationData.countryCodeAlpha2).toEqual(null)
+  })
+
+  it('works for v14 to v15', () => {
+    const v14Stub = {
+      ...v14Schema,
+      verify: {
+        ...v14Schema.verify,
+        seenVerificationNux: true,
+      },
+    }
+    const migratedSchema = migrations[15](v14Stub)
+    expect(migratedSchema.identity.hasSeenVerificationNux).toEqual(true)
+    expect(migratedSchema.identity).toMatchInlineSnapshot(`
+      {
+        "acceptedAttestationCodes": [],
+        "addressToDataEncryptionKey": {},
+        "addressToDisplayName": {},
+        "addressToE164Number": {},
+        "askedContactsPermission": false,
+        "attestationInputStatus": [
+          "Inputting",
+          "Disabled",
+          "Disabled",
+        ],
+        "attestationsCode": [],
+        "contactMappingProgress": {
+          "current": 0,
+          "total": 0,
+        },
+        "e164NumberToAddress": {},
+        "e164NumberToSalt": {},
+        "hasSeenVerificationNux": true,
+        "importContactsProgress": {
+          "current": 0,
+          "status": 0,
+          "total": 0,
+        },
+        "isLoadingImportContacts": false,
+        "lastRevealAttempt": null,
+        "matchedContacts": {},
+        "numCompleteAttestations": 0,
+        "secureSendPhoneNumberMapping": {},
+        "startedVerification": false,
+        "verificationFailed": false,
+        "verificationStatus": 0,
+        "walletToAccountAddress": {},
+      }
+    `)
+    expect(migratedSchema.verify).toMatchInlineSnapshot(`
+      {
+        "TEMPORARY_override_withoutVerification": undefined,
+        "actionableAttestations": [],
+        "currentState": {
+          "type": "Idle",
+        },
+        "komenci": {
+          "callbackUrl": undefined,
+          "captchaToken": "",
+          "errorTimestamps": [],
+          "sessionActive": false,
+          "sessionToken": "",
+          "unverifiedMtwAddress": null,
+        },
+        "komenciAvailable": "UNKNOWN",
+        "retries": 0,
+        "status": {
+          "completed": 0,
+          "isVerified": false,
+          "komenci": true,
+          "numAttestationsRemaining": 3,
+          "total": 0,
+        },
+        "withoutRevealing": false,
+      }
+    `)
+  })
+  it('works for v15 to v16', () => {
+    const migratedSchema = migrations[16]({
+      ...v15Schema,
+      stableToken: {
+        ...v15Schema.stableToken,
+        balance: '150',
+      },
+      escrow: {
+        isReclaiming: true,
+        sentEscrowedPayments: [{ object: 'with keys' }],
+      },
+    })
+    expect(migratedSchema.localCurrency.exchangeRates).toBeDefined()
+    expect(migratedSchema.localCurrency.exchangeRates[Currency.Dollar]).toEqual(
+      v15Schema.localCurrency.exchangeRate
+    )
+    expect(migratedSchema.stableToken.balance).toBeUndefined()
+    expect(migratedSchema.stableToken.balances[Currency.Dollar]).toEqual('150')
+    expect(migratedSchema.escrow.isReclaiming).toBeFalsy()
+    expect(migratedSchema.escrow.sentEscrowedPayments.length).toEqual(0)
+  })
+  it('works for v16 to v17', () => {
+    const migratedSchema = migrations[17](v16Schema)
+    expect(migratedSchema.fiatExchanges.lastUsedProvider).not.toBeDefined()
+  })
+  it('works for v17 to v18', () => {
+    expect(v17Schema.walletConnect.pairings).toBeDefined()
+    const migratedSchema = migrations[18](v17Schema)
+    expect(migratedSchema.walletConnect.v2.pairings).not.toBeDefined()
+  })
+  it('works for v18 to v19', () => {
+    // Test normal case
+    const migratedSchema = migrations[19](v18Schema)
+    // No changes expected
+    expect(migratedSchema).toBe(v18Schema)
+
+    // Test incorrect migrated state from v18 where v2 became an empty object
+    // if state.walletConnect was previously undefined
+    const v18Stub = {
+      ...v18Schema,
+      walletConnect: {
+        ...v18Schema.walletConnect,
+        v2: {},
+      },
+    }
+    const migratedSchema2 = migrations[19](v18Stub)
+    expect(migratedSchema2.walletConnect.v1).toBe(v18Schema.walletConnect.v1)
+    expect(migratedSchema2.walletConnect.v2).toBeUndefined()
+  })
+  it('works for v21 to v22', () => {
+    const migratedSchema = migrations[22](v21Schema)
+
+    expect(migratedSchema.i18n).toEqual({
+      language: 'es-419',
+      allowOtaTranslations: false,
+      otaTranslationsLastUpdate: 0,
+      otaTranslationsAppVersion: '0',
+      otaTranslationsLanguage: '',
+    })
+    expect(migratedSchema.app.language).toBe(undefined)
+  })
+
+  it('works for v28 to v29', () => {
+    expect(v28Schema.web3.fornoMode).toBe(false)
+    const migratedSchema = migrations[29](v28Schema)
+
+    expect(migratedSchema.web3.fornoMode).toBe(true)
+    expect(migratedSchema.web3.hadFornoDisabled).toBe(true)
+  })
+  it('works for v35 to v36', () => {
+    const oldSchema = v35Schema
+    const migratedSchema = migrations[36](oldSchema)
+
+    const expectedSchema: any = { ...oldSchema }
+    expectedSchema.account.finclusiveKycStatus = FinclusiveKycStatus.NotSubmitted
+    expectedSchema.app.maxNumRecentDapps = 0
+    expectedSchema.app.recentDapps = []
+
+    expect(migratedSchema).toMatchObject(expectedSchema)
+  })
+  it('works for v36 to v37', () => {
+    const oldSchema = v36Schema
+    const migratedSchema = migrations[37](oldSchema)
+
+    const expectedSchema: any = { ...oldSchema }
+    expectedSchema.app.showPriceChangeIndicatorInBalances = false
+
+    expect(migratedSchema).toMatchObject(expectedSchema)
+  })
+  it('works for v37 to v38', () => {
+    const oldSchema = v37Schema
+    const migratedSchema = migrations[38](oldSchema)
+
+    const expectedSchema: any = _.cloneDeep(oldSchema)
+    expectedSchema.app.skipVerification = false
+
+    expect(migratedSchema).toMatchObject(expectedSchema)
+  })
+  it('works for v41 to v42', () => {
+    const oldSchema = v41Schema
+    const migratedSchema = migrations[42](oldSchema)
+
+    const expectedSchema: any = _.cloneDeep(oldSchema)
+    expectedSchema.app.skipProfilePicture = false
+
+    expect(migratedSchema).toMatchObject(expectedSchema)
+  })
+  it('works for v43 to v44', () => {
+    const oldSchema = v43Schema
+    const migratedSchema = migrations[44](oldSchema)
+
+    const expectedSchema: any = _.cloneDeep(oldSchema)
+    expectedSchema.account.finclusiveRegionSupported = false
+    expectedSchema.app.finclusiveUnsupportedStates = ['NY', 'TX']
+
+    expect(migratedSchema).toMatchObject(expectedSchema)
+  })
+  it('works for v45 to v46', () => {
+    const migratedSchema = migrations[46](v45Schema)
+
+    const expectedSchema: any = _.cloneDeep(v45Schema)
+    expectedSchema.cloudFunctionsApi = undefined
+
+    expect(migratedSchema).toMatchObject(expectedSchema)
+  })
+  it('works for v46 to v47', () => {
+    const migratedSchema = migrations[47](v46Schema)
+
+    const expectedSchema: any = _.cloneDeep(v46Schema)
+    delete expectedSchema.app.multiTokenUseSendFlow
+    delete expectedSchema.app.multiTokenUseUpdatedFeed
+    delete expectedSchema.app.multiTokenShowHomeBalances
+
+    expect(migratedSchema).toMatchObject(expectedSchema)
+  })
+  it('works for v49 to v50', () => {
+    const migratedSchema = migrations[50](v49Schema)
+
+    const expectedSchema: any = _.cloneDeep(v49Schema)
+    delete expectedSchema.app.walletConnectV2Enabled
+    delete expectedSchema.walletConnect.v2
+
+    expect(migratedSchema).toMatchObject(expectedSchema)
+  })
+
+  it('works for v50 to v51', () => {
+    const oldSchema = v50Schema
+    const migratedSchema = migrations[51](oldSchema)
+
+    const expectedSchema: any = _.cloneDeep(oldSchema)
+    expectedSchema.app.celoWithdrawalEnabledInExchange = true
+
+    expect(migratedSchema).toMatchObject(expectedSchema)
+  })
+
+  it('works for v51 to v52', () => {
+    const oldSchema = v51Schema
+    const migratedSchema = migrations[52](oldSchema)
+
+    const expectedSchema: any = _.cloneDeep(oldSchema)
+    expectedSchema.app.fiatConnectCashInEnabled = false
+    expectedSchema.app.fiatConnectCashOutEnabled = false
+
+    expect(migratedSchema).toMatchObject(expectedSchema)
+  })
+
+  it('works for v52 to v53', () => {
+    const oldSchema = v52Schema
+    const migratedSchema = migrations[53](oldSchema)
+
+    const expectedSchema: any = _.cloneDeep(oldSchema)
+    delete expectedSchema.geth
+    delete expectedSchema.account.promptFornoIfNeeded
+    delete expectedSchema.account.retryVerificationWithForno
+    delete expectedSchema.web3.fornoMode
+    delete expectedSchema.web3.hadFornoDisabled
+    delete expectedSchema.web3.latestBlockNumber
+    delete expectedSchema.web3.syncProgress
+
+    expect(migratedSchema).toMatchObject(expectedSchema)
+  })
+
+  it('works for v53 to v54', () => {
+    const dapp = {
+      name: 'Ubeswap',
+      description: 'Swap any token, enter a pool, or farm your crypto',
+      dappUrl: 'https://app.ubeswap.org/',
+      categoryId: 'exchanges',
+      iconUrl: 'https://raw.githubusercontent.com/valora-xyz/dapp-list/main/assets/ubeswap.png',
+      isFeatured: false,
+      id: 'ubeswap',
+    }
+    const dappsInfo = {
+      dappsWebViewEnabled: true,
+      activeDapp: dapp,
+      maxNumRecentDapps: 8,
+      recentDapps: [dapp],
+      dappListApiUrl: 'https://www.dapplist.com',
+    }
+
+    const oldSchema = {
+      ...v53Schema,
+      app: {
+        ...v53Schema.app,
+        ...dappsInfo,
+      },
+    }
+    const migratedSchema = migrations[54](oldSchema)
+
+    const expectedSchema: any = _.cloneDeep(oldSchema)
+    delete expectedSchema.app.dappsWebViewEnabled
+    delete expectedSchema.app.activeDapp
+    delete expectedSchema.app.maxNumRecentDapps
+    delete expectedSchema.app.recentDapps
+    delete expectedSchema.app.dappListApiUrl
+    expectedSchema.dapps = dappsInfo
+
+    expect(migratedSchema).toMatchObject(expectedSchema)
+  })
+
+  it('works for v56 to v57', () => {
+    const oldSchema = v56Schema
+    const migratedSchema = migrations[57](oldSchema)
+
+    const expectedSchema: any = _.cloneDeep(oldSchema)
+    expectedSchema.app.visualizeNFTsEnabledInHomeAssetsPage = false
+
+    expect(migratedSchema).toMatchObject(expectedSchema)
+  })
+
+  it('works for v57 to v58', () => {
+    const oldSchema = v57Schema
+    const migratedSchema = migrations[58](oldSchema)
+
+    const expectedSchema: any = _.cloneDeep(oldSchema)
+    expectedSchema.app.coinbasePayEnabled = false
+
+    expect(migratedSchema).toMatchObject(expectedSchema)
+  })
+
+  it('works for v58 to v59', () => {
+    const oldTransactions = [
+      {
+        metadata: {
+          title: null,
+          comment: '',
+          subtitle: null,
+          image: null,
+        },
+        __typename: 'TokenTransferV2',
+        block: '14255636',
+        transactionHash: '0xf4e59db43c9051947ffe8a29a09c8f85dcf540699855166aa68f11cda3014b72',
+        type: 'RECEIVED',
+        amount: {
+          value: '0.01',
+          tokenAddress: '0x765de816845861e75a25fca122bb6898b8b1282a',
+          localAmount: {
+            currencyCode: 'USD',
+            exchangeRate: '1',
+            value: '0.01',
+          },
+        },
+        fees: null,
+        timestamp: 1658945996000,
+        address: '0xde33e71faecdead20e6a8af8f362d2236cba005f',
+      },
+      {},
+    ]
+    const oldSchema = {
+      ...v58Schema,
+      transactions: {
+        ...v58Schema.transactions,
+        transactions: oldTransactions,
+      },
+    }
+    const migratedSchema = migrations[59](oldSchema)
+
+    const expectedSchema: any = _.cloneDeep(oldSchema)
+    expectedSchema.transactions.transactions = [oldTransactions[0]]
+
+    expect(migratedSchema).toMatchObject(expectedSchema)
+  })
+
+  it('works for v59 to v60', () => {
+    const oldSchema = v59Schema
+    const migratedSchema = migrations[60](oldSchema)
+
+    const expectedSchema: any = _.cloneDeep(oldSchema)
+    expectedSchema.fiatConnect = {}
+    expectedSchema.fiatConnect.quotes = []
+    expectedSchema.fiatConnect.quotesLoading = false
+    expectedSchema.fiatConnect.quotesError = null
+
+    expect(migratedSchema).toMatchObject(expectedSchema)
+  })
+
+  it('works for v62 to v63', () => {
+    const oldSchema = v62Schema
+    const migratedSchema = migrations[63](oldSchema)
+
+    const expectedSchema: any = _.cloneDeep(oldSchema)
+    expectedSchema.app.superchargeTokenConfigByToken = {}
+    delete expectedSchema.app.superchargeTokens
+
+    expect(migratedSchema).toStrictEqual(expectedSchema)
+  })
+
+  it('works for v75 to v76', () => {
+    const oldSchema = v75Schema
+    const migratedSchema = migrations[76](oldSchema)
+
+    const expectedSchema: any = _.cloneDeep(oldSchema)
+    expectedSchema.app.showGuidedOnboardingCopy = false
+    // shall be the default value as configured in REMOTE_CONFIG_VALUES_DEFAULTS
+    expect(migratedSchema).toStrictEqual(expectedSchema)
+  })
+
+  it('works from v81 to v82', () => {
+    const oldSchema = v81Schema
+    const migratedSchema = migrations[82](oldSchema)
+
+    const expectedSchema: any = _.cloneDeep(oldSchema)
+    expectedSchema.swap = {
+      swapState: 'quote',
+      swapInfo: null,
+      swapUserInput: null,
+    }
+
+    expect(migratedSchema).toStrictEqual(expectedSchema)
+  })
+
+  it('works from v84 to v85', () => {
+    const oldSchema = v84Schema
+    const migratedSchema = migrations[85](oldSchema)
+
+    const expectedSchema: any = _.cloneDeep(oldSchema)
+    delete expectedSchema.app.swapFeeEnabled
+    delete expectedSchema.app.swapFeePercentage
+    expect(migratedSchema).toStrictEqual(expectedSchema)
+  })
+
+  it('works from v98 to v99', () => {
+    const oldSchema = {
+      ...v98Schema,
+      dapps: {
+        ...v98Schema.dapps,
+        recentDapps: [
+          {
+            name: 'Ubeswap',
+            description: 'Swap any token, enter a pool, or farm your crypto',
+            dappUrl: 'https://app.ubeswap.org/',
+            categoryId: 'exchanges',
+            iconUrl:
+              'https://raw.githubusercontent.com/valora-xyz/dapp-list/main/assets/ubeswap.png',
+            isFeatured: false,
+            id: 'ubeswap',
+          },
+        ],
+        favoriteDapps: [
+          {
+            name: 'Moola',
+            description: 'Lend, borrow, or add to a pool to earn rewards',
+            dappUrl: `${DEEP_LINK_URL_SCHEME}://wallet/moolaScreen`,
+            categoryId: 'lend',
+            iconUrl: 'https://raw.githubusercontent.com/valora-xyz/dapp-list/main/assets/moola.png',
+            isFeatured: false,
+            id: 'moola',
+          },
+        ],
+      },
+    }
+    const migratedSchema = migrations[99](oldSchema)
+
+    const expectedSchema: any = {
+      ...v98Schema,
+      dapps: {
+        ...v98Schema.dapps,
+        recentDappIds: ['ubeswap'],
+        favoriteDappIds: ['moola'],
+      },
+    }
+    delete expectedSchema.dapps.recentDapps
+    delete expectedSchema.dapps.favoriteDapps
+    expect(migratedSchema).toStrictEqual(expectedSchema)
+  })
+
+  it('works from v99 to v100', () => {
+    const oldSchema = v99Schema
+    const migratedSchema = migrations[100](oldSchema)
+
+    const expectedSchema: any = _.cloneDeep(oldSchema)
+    delete expectedSchema.app.celoNewsEnabled
+
+    expect(migratedSchema).toStrictEqual(expectedSchema)
+  })
+
+  it('works from v103 to v104', () => {
+    const oldSchema = v103Schema
+    const migratedSchema = migrations[104](oldSchema)
+
+    const expectedSchema: any = _.cloneDeep(oldSchema)
+    delete expectedSchema.goldToken
+    delete expectedSchema.stableToken
+    expectedSchema.account.celoEducationCompleted = oldSchema.goldToken.educationCompleted
+
+    expect(migratedSchema).toStrictEqual(expectedSchema)
+  })
+
+  it('works from v104 to v105', () => {
+    const oldSchema = v104Schema
+    const migratedSchema = migrations[105](oldSchema)
+
+    const expectedSchema: any = _.cloneDeep(oldSchema)
+    expectedSchema.web3.twelveWordMnemonicEnabled = false
+    expect(migratedSchema).toStrictEqual(expectedSchema)
+  })
+
+  it('works from v106 to v107', () => {
+    const oldSchema = {
+      ...v106Schema,
+      fiatConnect: {
+        ...v106Schema.fiatConnect,
+        cachedFiatAccountUses: [
+          {
+            providerId: 'provider-two',
+            cryptoType: Currency.Dollar,
+          },
+          {
+            providerId: 'provider-one',
+            cryptoType: Currency.Celo,
+          },
+        ],
+        cachedQuoteParams: {
+          'some-provider': {
+            ['some-schema']: {
+              cryptoAmount: '10',
+              fiatAmount: '10',
+              cryptoType: Currency.Dollar,
+            },
+          },
+          'some-other-provider': {
+            ['some-schema']: {
+              cryptoAmount: '10',
+              fiatAmount: '10',
+              cryptoType: Currency.Celo,
+            },
+          },
+        },
+      },
+    }
+    const migratedSchema = migrations[107](oldSchema)
+
+    const freshSchema: any = _.cloneDeep(oldSchema)
+    const expectedSchema = {
+      ...freshSchema,
+      fiatConnect: {
+        ...freshSchema.fiatConnect,
+        cachedFiatAccountUses: [
+          {
+            providerId: 'provider-two',
+            cryptoType: CiCoCurrency.cUSD,
+          },
+          {
+            providerId: 'provider-one',
+            cryptoType: CiCoCurrency.CELO,
+          },
+        ],
+        cachedQuoteParams: {
+          'some-provider': {
+            ['some-schema']: {
+              cryptoAmount: '10',
+              fiatAmount: '10',
+              cryptoType: CiCoCurrency.cUSD,
+            },
+          },
+          'some-other-provider': {
+            ['some-schema']: {
+              cryptoAmount: '10',
+              fiatAmount: '10',
+              cryptoType: CiCoCurrency.CELO,
+            },
+          },
+        },
+      },
+    }
+    expect(migratedSchema).toStrictEqual(expectedSchema)
+  })
+  it('works from v112 to v113', () => {
+    const oldSchema = v112Schema
+    const migratedSchema = migrations[113](oldSchema)
+
+    const expectedSchema: any = _.cloneDeep(oldSchema)
+    delete expectedSchema.app.skipProfilePicture
+    delete expectedSchema.app.showGuidedOnboardingCopy
+    delete expectedSchema.app.createAccountCopyTestType
+
+    expect(migratedSchema).toStrictEqual(expectedSchema)
+  })
+  it('works from v115 to v116', () => {
+    const oldSchema = v115Schema
+    const migratedSchema = migrations[116](oldSchema)
+    const expectedSchema: any = _.cloneDeep(oldSchema)
+    expectedSchema.account.startOnboardingTime = undefined
+    expect(migratedSchema).toStrictEqual(expectedSchema)
+  })
+
+  it('works from v124 to v125', () => {
+    const oldSchema = v124Schema
+    const migratedSchema = migrations[125](oldSchema)
+    const expectedSchema: any = _.cloneDeep(oldSchema)
+    delete expectedSchema.app.celoNews.enabled
+    expect(migratedSchema).toStrictEqual(expectedSchema)
+  })
+
+  it('works from v125 to v126', () => {
+    const oldSchmea = v125Schema
+    const migratedSchema = migrations[126](oldSchmea)
+    const expectedSchema: any = _.cloneDeep(oldSchmea)
+    expectedSchema.app.inAppReviewLastInteractionTimestamp = null
+    expect(migratedSchema).toStrictEqual(expectedSchema)
+  })
+
+  it('works from v130 to v131', () => {
+    const oldSchemaWithV1Dapp = {
+      ...v130Schema,
+      dapps: {
+        ...v130Schema.dapps,
+        dappsList: [
+          {
+            name: 'Ubeswap',
+            description: 'Swap any token, enter a pool, or farm your crypto',
+            dappUrl: 'https://app.ubeswap.org/',
+            categoryId: 'exchanges',
+            iconUrl:
+              'https://raw.githubusercontent.com/valora-xyz/dapp-list/main/assets/ubeswap.png',
+            isFeatured: false,
+            id: 'ubeswap',
+          },
+        ],
+        activeDapp: {
+          name: 'Ubeswap',
+          description: 'Swap any token, enter a pool, or farm your crypto',
+          dappUrl: 'https://app.ubeswap.org/',
+          categoryId: 'exchanges',
+          iconUrl: 'https://raw.githubusercontent.com/valora-xyz/dapp-list/main/assets/ubeswap.png',
+          isFeatured: false,
+          id: 'ubeswap',
+          openedFrom: 'featured',
+        },
+      },
+    }
+    const expectedSchemaWithV2Dapp: any = {
+      ...v130Schema,
+      dapps: {
+        ...v130Schema.dapps,
+        dappsList: [
+          {
+            name: 'Ubeswap',
+            description: 'Swap any token, enter a pool, or farm your crypto',
+            dappUrl: 'https://app.ubeswap.org/',
+            categories: ['exchanges'],
+            iconUrl:
+              'https://raw.githubusercontent.com/valora-xyz/dapp-list/main/assets/ubeswap.png',
+            id: 'ubeswap',
+          },
+        ],
+        activeDapp: {
+          name: 'Ubeswap',
+          description: 'Swap any token, enter a pool, or farm your crypto',
+          dappUrl: 'https://app.ubeswap.org/',
+          categories: ['exchanges'],
+          iconUrl: 'https://raw.githubusercontent.com/valora-xyz/dapp-list/main/assets/ubeswap.png',
+          id: 'ubeswap',
+          openedFrom: 'featured',
+        },
+      },
+    }
+
+    const migratedV1Schema = migrations[131](oldSchemaWithV1Dapp)
+    const migratedV2Schema = migrations[131](expectedSchemaWithV2Dapp)
+
+    expect(migratedV1Schema).toMatchObject(expectedSchemaWithV2Dapp)
+    expect(migratedV2Schema).toMatchObject(expectedSchemaWithV2Dapp)
+  })
+
+  it('works from v132 to v133', () => {
+    const oldSchema = v132Schema
+    const migratedSchema = migrations[133](oldSchema)
+    const expectedSchema: any = _.cloneDeep(oldSchema)
+    expectedSchema.nfts = {
+      nfts: [],
+      nftsError: null,
+      nftsLoading: false,
+    }
+    expect(migratedSchema).toStrictEqual(expectedSchema)
+  })
+
+  it('works from v133 to v134', () => {
+    const oldSchema = v133Schema
+    const migratedSchema = migrations[134](oldSchema)
+    const expectedSchema: any = _.cloneDeep(oldSchema)
+    expectedSchema.positions.previewApiUrl = null
+    expect(migratedSchema).toStrictEqual(expectedSchema)
+  })
+
+  it('works from v136 to v137', () => {
+    const oldSchema = v136Schema
+    const migratedSchema = migrations[137](oldSchema)
+    const expectedSchema: any = _.cloneDeep(oldSchema)
+    expectedSchema.walletConnect.sessions = oldSchema.walletConnect.v2.sessions
+    expectedSchema.walletConnect.pendingActions = oldSchema.walletConnect.v2.pendingActions
+    expectedSchema.walletConnect.pendingSessions = oldSchema.walletConnect.v2.pendingSessions
+    delete expectedSchema.walletConnect.v1
+    delete expectedSchema.walletConnect.v2
+    expect(migratedSchema).toStrictEqual(expectedSchema)
+  })
+  it('works from v144 to v145', () => {
+    // Ensure that all of TokenTransfer, TokenExchange, and NftTransfer migrate correctly.
+    // Namely, that the __typename is updated to V3 and that chain is added to each TX.
+    // Also check that chain is added to standby transactions.
+    const oldSchema = {
+      ...v144Schema,
+      transactions: {
+        ...v144Schema.transactions,
+        standbyTransactions: [
+          {
+            context: { id: 'test' },
+            type: TokenTransactionTypeV2.Sent,
+            status: TransactionStatus.Pending,
+            value: '0.5',
+            tokenAddress: 'mock-address',
+            comment: '',
+            timestamp: 1542300000,
+            address: '0xd68360cce1f1ff696d898f58f03e0f1252f2ea33',
+          },
+        ],
+        transactions: [
+          {
+            __typename: 'TokenTransferV2',
+            type: TokenTransactionTypeV2.Sent,
+            transactionHash: '123',
+            timestamp: 456,
+            block: '789',
+            address: 'some-address',
+            amount: {
+              value: new BigNumber(0),
+              tokenAddress: 'some-token-address',
+              localAmount: {
+                value: new BigNumber(1),
+                currencyCode: 'USD',
+                exchangeRate: '1',
+              },
+            },
+            metadata: {},
+            fees: [],
+          },
+          {
+            __typename: 'NftTransferV2',
+            type: TokenTransactionTypeV2.NftReceived,
+            transactionHash: '123',
+            timestamp: 456,
+            block: '789',
+            nfts: [],
+            fees: [],
+          },
+          {
+            __typename: 'TokenExchangeV2',
+            type: TokenTransactionTypeV2.Exchange,
+            transactionHash: '123',
+            timestamp: 456,
+            block: '789',
+            inAmount: {
+              value: new BigNumber(0),
+              tokenAddress: 'some-token-address',
+              localAmount: {
+                value: new BigNumber(1),
+                currencyCode: 'USD',
+                exchangeRate: '1',
+              },
+            },
+            outAmount: {
+              value: new BigNumber(0),
+              tokenAddress: 'some-token-address',
+              localAmount: {
+                value: new BigNumber(1),
+                currencyCode: 'USD',
+                exchangeRate: '1',
+              },
+            },
+            metadata: {},
+            fees: [],
+          },
+        ],
+      },
+    }
+    const expectedSchema = {
+      ...v144Schema,
+      transactions: {
+        ...v144Schema.transactions,
+        standbyTransactions: [
+          {
+            context: { id: 'test' },
+            network: Network.Celo,
+            type: TokenTransactionTypeV2.Sent,
+            status: TransactionStatus.Pending,
+            value: '0.5',
+            tokenAddress: 'mock-address',
+            comment: '',
+            timestamp: 1542300000,
+            address: '0xd68360cce1f1ff696d898f58f03e0f1252f2ea33',
+          },
+        ],
+        transactions: [
+          {
+            __typename: 'TokenTransferV3',
+            network: Network.Celo,
+            type: TokenTransactionTypeV2.Sent,
+            transactionHash: '123',
+            timestamp: 456,
+            block: '789',
+            address: 'some-address',
+            amount: {
+              value: new BigNumber(0),
+              tokenAddress: 'some-token-address',
+              localAmount: {
+                value: new BigNumber(1),
+                currencyCode: 'USD',
+                exchangeRate: '1',
+              },
+            },
+            metadata: {},
+            fees: [],
+          },
+          {
+            __typename: 'NftTransferV3',
+            network: Network.Celo,
+            type: TokenTransactionTypeV2.NftReceived,
+            transactionHash: '123',
+            timestamp: 456,
+            block: '789',
+            nfts: [],
+            fees: [],
+          },
+          {
+            __typename: 'TokenExchangeV3',
+            network: Network.Celo,
+            type: TokenTransactionTypeV2.Exchange,
+            transactionHash: '123',
+            timestamp: 456,
+            block: '789',
+            inAmount: {
+              value: new BigNumber(0),
+              tokenAddress: 'some-token-address',
+              localAmount: {
+                value: new BigNumber(1),
+                currencyCode: 'USD',
+                exchangeRate: '1',
+              },
+            },
+            outAmount: {
+              value: new BigNumber(0),
+              tokenAddress: 'some-token-address',
+              localAmount: {
+                value: new BigNumber(1),
+                currencyCode: 'USD',
+                exchangeRate: '1',
+              },
+            },
+            metadata: {},
+            fees: [],
+          },
+        ],
+      },
+    }
+    const migratedSchema = migrations[145](oldSchema)
+    expect(migratedSchema).toStrictEqual(expectedSchema)
+  })
+
+  it('works from v145 to v146', () => {
+    const oldSchema = v145Schema
+    const migratedSchema = migrations[146](oldSchema)
+    const expectedSchema: any = _.cloneDeep(oldSchema)
+    expectedSchema.localCurrency.usdToLocalRate =
+      oldSchema.localCurrency.exchangeRates[Currency.Dollar]
+    delete expectedSchema.localCurrency.exchangeRates
+    expect(migratedSchema).toStrictEqual(expectedSchema)
+  })
+
+  it('works from v146 to v147', () => {
+    const oldSchema = {
+      ...v146Schema,
+      transactions: {
+        ...v146Schema.transactions,
+        standbyTransactions: [
+          {
+            context: { id: 'test' },
+            network: Network.Celo,
+            type: TokenTransactionTypeV2.Sent,
+            status: TransactionStatus.Pending,
+            value: '0.5',
+            tokenAddress: 'mock-address',
+            comment: '',
+            timestamp: 1542300000,
+            address: '0xd68360cce1f1ff696d898f58f03e0f1252f2ea33',
+          },
+        ],
+        transactions: [
+          {
+            __typename: 'TokenTransferV3',
+            type: TokenTransactionTypeV2.Sent,
+            network: Network.Celo,
+            transactionHash: '123',
+            timestamp: 456,
+            block: '789',
+            address: 'some-address',
+            amount: {
+              value: new BigNumber(0),
+              tokenAddress: 'some-token-address',
+              localAmount: {
+                value: new BigNumber(1),
+                currencyCode: 'USD',
+                exchangeRate: '1',
+              },
+            },
+            metadata: {},
+            fees: [],
+          },
+          {
+            __typename: 'NftTransferV3',
+            network: Network.Ethereum,
+            type: TokenTransactionTypeV2.NftReceived,
+            transactionHash: '123',
+            timestamp: 456,
+            block: '789',
+            nfts: [],
+            fees: [],
+          },
+        ],
+      },
+    }
+    const expectedSchema = {
+      ...v146Schema,
+      transactions: {
+        ...v146Schema.transactions,
+        standbyTransactions: [
+          {
+            context: { id: 'test' },
+            networkId: NetworkId['celo-alfajores'],
+            type: TokenTransactionTypeV2.Sent,
+            status: TransactionStatus.Pending,
+            value: '0.5',
+            tokenAddress: 'mock-address',
+            comment: '',
+            timestamp: 1542300000,
+            address: '0xd68360cce1f1ff696d898f58f03e0f1252f2ea33',
+          },
+        ],
+        transactions: [
+          {
+            __typename: 'TokenTransferV3',
+            networkId: NetworkId['celo-alfajores'],
+            type: TokenTransactionTypeV2.Sent,
+            transactionHash: '123',
+            timestamp: 456,
+            block: '789',
+            address: 'some-address',
+            amount: {
+              value: new BigNumber(0),
+              tokenAddress: 'some-token-address',
+              localAmount: {
+                value: new BigNumber(1),
+                currencyCode: 'USD',
+                exchangeRate: '1',
+              },
+            },
+            metadata: {},
+            fees: [],
+          },
+          {
+            __typename: 'NftTransferV3',
+            networkId: NetworkId['ethereum-sepolia'],
+            type: TokenTransactionTypeV2.NftReceived,
+            transactionHash: '123',
+            timestamp: 456,
+            block: '789',
+            nfts: [],
+            fees: [],
+          },
+        ],
+      },
+    }
+    const migratedSchema = migrations[147](oldSchema)
+    expect(migratedSchema).toStrictEqual(expectedSchema)
+  })
+
+  it('works from v148 to v149', () => {
+    expect(
+      migrations[149]({
+        ...v148Schema,
+        app: {
+          ...v148Schema.app,
+          activeScreen: 'AppLoading',
+        },
+      })
+    ).toStrictEqual({
+      ...v148Schema,
+      app: {
+        ...v148Schema.app,
+        activeScreen: 'Main',
+      },
+    })
+  })
+
+  it('works from 159 to 160', () => {
+    const preMigrationSchema = {
+      ...v159Schema,
+    }
+    preMigrationSchema.app.activeScreen = 'PaymentRequestConfirmation'
+    const migratedSchema = migrations[160](preMigrationSchema)
+
+    // paymentRequest dropped, activeScreen changed to Main from PaymentRequestConfirmation
+    expect('paymentRequest' in migratedSchema).toBe(false)
+    expect(migratedSchema.app.activeScreen).toEqual('Main')
+
+    // should otherwise be equal
+    expect(_.omit(migratedSchema, 'app.activeScreen')).toStrictEqual(
+      _.omit(preMigrationSchema, 'app.activeScreen', 'paymentRequest')
+    )
+  })
+
+  it('works from 160 to 161', () => {
+    const preMigrationSchema = {
+      ...v159Schema,
+    }
+    preMigrationSchema.transactions.standbyTransactions = [
+      {
+        context: { id: 'someId' },
+        networkId: 'celo-alfajores',
+        type: 'SENT',
+        status: TransactionStatus.Pending,
+        value: '123',
+        tokenId: 'someTokenId',
+        tokenAddress: '0xabc',
+        comment: 'some comment',
+        timestamp: 123456789,
+        address: '0x123',
+        hash: 'someHash',
+      },
+    ] as any
+    const migratedSchema = migrations[161](preMigrationSchema)
+
+    expect(migratedSchema.transactions.standbyTransactions).toEqual([
+      {
+        __typename: 'TokenTransferV3',
+        type: TokenTransactionTypeV2.Sent,
+        context: { id: 'someId' },
+        networkId: 'celo-alfajores',
+        amount: {
+          value: '123',
+          tokenId: 'someTokenId',
+          tokenAddress: '0xabc',
+        },
+        timestamp: 123456789,
+        address: '0x123',
+        transactionHash: 'someHash',
+        metadata: {
+          comment: 'some comment',
+        },
+        status: TransactionStatus.Pending,
+      },
+    ])
+  })
+
+  it('works from 164 to 165', () => {
+    const preMigrationSchema = {
+      ...v164Schema,
+    }
+    const celoSwap = {
+      __typename: 'TokenExchangeV3',
+      type: 'SWAP_TRANSACTION',
+      networkId: 'celo-alfajores',
+      block: '22127052',
+      transactionHash: '0x28fc7261a01bbbe97d5cc1f4c41ccf278bb9980ab12b4cd4bf62b76f137a6691',
+    }
+    const celoTransfer = {
+      __typename: 'TokenTransferV3',
+      block: '22115616',
+      transactionHash: '0x9fa0eb09da50ead38ba96fba8e7d8d341af81fd407cda0fae400943c173371c1',
+      type: 'SENT',
+      // no networkId, for older clients
+    }
+    const ethereumTransfer = {
+      __typename: 'TokenTransferV3',
+      block: '22115737',
+      transactionHash: '0x8f3cb9816418ec3df206b914d88285f3eb251b6a07a8b89b11379eed57fec22e',
+      type: 'SENT',
+      networkId: 'ethereum-sepolia',
+    }
+    preMigrationSchema.transactions.transactions = [celoSwap, ethereumTransfer, celoTransfer]
+    const migratedSchema = migrations[165](preMigrationSchema)
+
+    expect(migratedSchema.transactions.transactionsByNetworkId).toEqual({
+      [NetworkId['celo-alfajores']]: [celoSwap, celoTransfer],
+      [NetworkId['ethereum-sepolia']]: [ethereumTransfer],
+    })
+    expect('transactions' in migratedSchema.transactions).toBe(false)
+  })
+
+  it('works from 166 to 167', () => {
+    const oldSchema = v166Schema
+    const migratedSchema = migrations[167](oldSchema)
+    const expectedSchema: any = _.cloneDeep(oldSchema)
+    expectedSchema.app.rampCashInButtonExpEnabled = false
+    expect(migratedSchema).toStrictEqual(expectedSchema)
+  })
+
+  it('works from 167 to 168', () => {
+    const oldSchema = v167Schema
+    const migratedSchema = migrations[168](oldSchema)
+    const expectedSchema: any = _.omit(oldSchema, 'swap.swapUserInput')
+    expect(migratedSchema).toStrictEqual(expectedSchema)
+  })
+
+  it('works from 171 to 172', () => {
+    const oldSchema = v171Schema
+    const migratedSchema = migrations[172](oldSchema)
+    const expectedSchema: any = _.cloneDeep(oldSchema)
+    delete expectedSchema.swap.swapInfo
+    expectedSchema.swap.currentSwap = null
+    expect(migratedSchema).toStrictEqual(expectedSchema)
+  })
+
+  it('works from 172 to 173', () => {
+    const oldSchema = v172Schema
+    const migratedSchema = migrations[173](oldSchema)
+    const expectedSchema: any = _.cloneDeep(oldSchema)
+    delete expectedSchema.swap.swapState
+    expect(migratedSchema).toStrictEqual(expectedSchema)
+  })
+
+  it('works from 174 to 175', () => {
+    const oldSchema = v174Schema
+    const migratedSchema = migrations[175](oldSchema)
+
+    // CELO
+    const celoToken = migratedSchema.tokens.tokenBalances['celo-alfajores:native']
+    expect(celoToken).not.toHaveProperty('isCoreToken')
+    expect(celoToken).toHaveProperty('isFeeCurrency', true)
+    expect(celoToken).toHaveProperty('canTransferWithComment', true)
+
+    // cUSD
+    const cUSDToken =
+      migratedSchema.tokens.tokenBalances[
+        'celo-alfajores:0x874069fa1eb16d44d622f2e0ca25eea172369bc1'
+      ]
+    expect(cUSDToken).not.toHaveProperty('isCoreToken')
+    expect(cUSDToken).toHaveProperty('isFeeCurrency', true)
+    expect(cUSDToken).toHaveProperty('canTransferWithComment', true)
+
+    // cEUR
+    const cEURToken =
+      migratedSchema.tokens.tokenBalances[
+        'celo-alfajores:0x10c892a6ec43a53e45d0b916b4b7d383b1b78c0f'
+      ]
+    expect(cEURToken).not.toHaveProperty('isCoreToken')
+    expect(cEURToken).toHaveProperty('isFeeCurrency', true)
+    expect(cEURToken).toHaveProperty('canTransferWithComment', true)
+
+    // Test Token
+    const testToken =
+      migratedSchema.tokens.tokenBalances[
+        'celo-alfajores:0x048f47d358ec521a6cf384461d674750a3cb58c8'
+      ]
+    expect(testToken).not.toHaveProperty('isCoreToken')
+    expect(testToken).not.toHaveProperty('isFeeCurrency')
+    expect(testToken).not.toHaveProperty('canTransferWithComment')
+
+    // Moola
+    const moolaToken =
+      migratedSchema.tokens.tokenBalances[
+        'celo-alfajores:0x17700282592D6917F6A73D0bF8AcCf4D578c131e'
+      ]
+    expect(moolaToken).not.toHaveProperty('isCoreToken')
+    expect(moolaToken).not.toHaveProperty('isFeeCurrency')
+    expect(moolaToken).not.toHaveProperty('canTransferWithComment')
+  })
+
+  it('works from 176 to 177', () => {
+    const oldSchema = v176Schema
+    const migratedSchema = migrations[177](oldSchema)
+    const expectedSchema: any = _.cloneDeep(oldSchema)
+    expectedSchema.swap.priceImpactWarningThreshold =
+      expectedSchema.swap.priceImpactWarningThreshold * 100
+    expect(migratedSchema).toStrictEqual(expectedSchema)
+  })
+
+  it('works from 177 to 178', () => {
+    const oldSchema = v177Schema
+    const migratedSchema = migrations[178](oldSchema)
+    const expectedSchema: any = _.cloneDeep(oldSchema)
+    delete expectedSchema.swap.guaranteedSwapPriceEnabled
+    expect(migratedSchema).toStrictEqual(expectedSchema)
+  })
+
+  it('works from 178 to 179', () => {
+    const oldSchema = v178Schema
+    const migratedSchema = migrations[179](oldSchema)
+    const expectedSchema: any = _.cloneDeep(oldSchema)
+    expectedSchema.priceHistory = {}
+    expect(migratedSchema).toStrictEqual(expectedSchema)
+  })
+
+  it('works from 179 to 180', () => {
+    const oldSchema = {
+      ...v179Schema,
+      send: {
+        ...v179Schema.send,
+        recentRecipients: [
+          // invitable recipients don't include an address
+          mockRecipient,
+          mockInvitableRecipient,
+          mockRecipient2,
+          mockInvitableRecipient2,
+        ],
+      },
+    }
+    const migratedSchema = migrations[180](oldSchema)
+    const expectedSchema: any = _.cloneDeep(oldSchema)
+    expectedSchema.send.recentRecipients = [mockRecipient, mockRecipient2]
+    expect(migratedSchema).toStrictEqual(expectedSchema)
+  })
+  it('works from 197 to 198', () => {
+    const oldSchema = {
+      ...v197Schema,
+      home: {
+        ...v197Schema.home,
+        nftCelebration: {
+          networkId: 'celo-alfajores',
+          contractAddress: '0xTEST',
+          displayed: true,
+        },
+      },
+    }
+    const migratedSchema = migrations[198](oldSchema)
+    const expectedSchema: any = _.cloneDeep(oldSchema)
+    expectedSchema.home.nftCelebration = null
+    expect(migratedSchema).toStrictEqual(expectedSchema)
+  })
+  it('works from 200 to 201', () => {
+    const oldSchema = {
+      ...v200Schema,
+      app: {
+        ...v200Schema.app,
+        hideHomeBalances: true,
+      },
+    }
+    const migratedSchema = migrations[201](oldSchema)
+    const expectedSchema: any = _.cloneDeep(oldSchema)
+    expectedSchema.app.hideBalances = true
+    delete expectedSchema.app.hideHomeBalances
+    expect(migratedSchema).toStrictEqual(expectedSchema)
+  })
+
+  it('works from 201 to 202', () => {
+    const oldSchema = v201Schema
+    const migratedSchema = migrations[202](oldSchema)
+    const expectedSchema: any = _.cloneDeep(oldSchema)
+    expectedSchema.walletConnect.pendingSessions = []
+    expect(migratedSchema).toStrictEqual(expectedSchema)
+  })
+
+  it('works from 203 to 204: recently inactive users', () => {
+    // users inactive since 4/2/2024 have legacy values in state
+    const oldSchema = {
+      ...v203Schema,
+      positions: {
+        ...(v203Schema.positions as any),
+        positions: mockPositionsLegacy,
+        shortcuts: mockShortcutsLegacy,
+      },
+    }
+    const expectedSchema = _.cloneDeep(oldSchema)
+    expectedSchema.positions.positions = mockPositionsLegacy2
+    expectedSchema.positions.shortcuts = [mockShortcuts[0]]
+    const migratedSchema = migrations[204](oldSchema)
+
+    expect(migratedSchema).toStrictEqual(expectedSchema)
+  })
+
+  it('works from 203 to 204: recently active users', () => {
+    // api has been returning 'networkId' and 'networkIds' fields since 4/2/2024. users active since then will have noop migration
+    const oldSchema = {
+      ...v203Schema,
+      positions: {
+        positions: mockPositionsLegacy2,
+        shortcuts: mockShortcuts,
+      },
+    }
+    const expectedSchema = _.cloneDeep(oldSchema)
+    const migratedSchema = migrations[204](oldSchema)
+    expect(migratedSchema).toStrictEqual(expectedSchema)
+  })
+
+  it('works from 214 to 215', () => {
+    const oldSchema = v214Schema
+    const migratedSchema = migrations[215](oldSchema)
+    const expectedSchema: any = _.cloneDeep(oldSchema)
+    expectedSchema.points.introHasBeenDismissed = false
+    expect(migratedSchema).toStrictEqual(expectedSchema)
+  })
+
+  it('works from 216 to 217', () => {
+    const oldSchema = v216Schema
+    const migratedSchema = migrations[217](oldSchema)
+    const expectedSchema: any = _.cloneDeep(oldSchema)
+    expectedSchema.points.trackOnceActivities = {
+      'create-wallet': false,
+    }
+    expect(migratedSchema).toStrictEqual(expectedSchema)
+  })
+
+  it('works from 222 to 223', () => {
+    const oldSchema = v222Schema
+    const migratedSchema = migrations[223](oldSchema)
+    const expectedSchema: any = _.cloneDeep(oldSchema)
+    expectedSchema.recipients = {
+      ..._.omit(oldSchema.recipients, 'valoraRecipientCache'),
+      appRecipientCache: {},
+    }
+    expect(migratedSchema).toStrictEqual(expectedSchema)
+  })
+
+  it('works from 227 to 228', () => {
+    const oldSchema = v227Schema
+    const migratedSchema = migrations[228](oldSchema)
+    const expectedSchema: any = _.cloneDeep(oldSchema)
+    ;(expectedSchema.identity = _.omit(
+      oldSchema.identity,
+      'walletToAccountAddress',
+      'e164NumberToSalt',
+      'addressToDataEncryptionKey'
+    )),
+      (expectedSchema.web3 = _.omit(
+        oldSchema.web3,
+        'accountInWeb3Keystore',
+        'dataEncryptionKey',
+        'isDekRegistered',
+        'mtwAddress'
+      ))
+    expect(migratedSchema).toStrictEqual(expectedSchema)
+  })
+  it('works from 228 to 229', () => {
+    const oldSchema = {
+      ...v228Schema,
+      transactions: {
+        ...v228Schema.transactions,
+        transactionsByNetworkId: {
+          ...v228Schema.transactions.transactionsByNetworkId,
+          [NetworkId['arbitrum-sepolia']]: [
+            { ...mockEarnDepositTransaction, providerId: 'aave-v3' },
+          ],
+        },
+        standbyTransactions: [
+          {
+            ...mockEarnDepositTransaction,
+            providerId: 'aave-v3',
+            status: TransactionStatus.Pending,
+          },
+          ...v228Schema.transactions.standbyTransactions,
+        ],
+      },
+    }
+    const migratedSchema = migrations[229](oldSchema)
+    const expectedSchema: any = _.cloneDeep(oldSchema)
+    expectedSchema.transactions.transactionsByNetworkId[
+      NetworkId['arbitrum-sepolia']
+    ][0].providerId = 'aave'
+    expectedSchema.transactions.standbyTransactions[0].providerId = 'aave'
+    expect(migratedSchema).toStrictEqual(expectedSchema)
+  })
+  it('works from 230 to 231', () => {
+    const oldSchema = v230Schema
+    const migratedSchema = migrations[231](oldSchema)
+    const expectedSchema: any = _.cloneDeep(oldSchema)
+    expectedSchema.jumpstart.introHasBeenSeen = false
+    expect(migratedSchema).toStrictEqual(expectedSchema)
+  })
+
+  it('works from 233 to 234', () => {
+    const oldSchema = v233Schema
+    const migratedSchema = migrations[234](oldSchema)
+    const expectedSchema: any = _.cloneDeep(oldSchema)
+    expectedSchema.transactions.feedFirstPage = []
+    expect(migratedSchema).toStrictEqual(expectedSchema)
+  })
+
+  // N.B. The 236 -> 237 migration tests are adapted from the old initial route handler tests
+  it('works from 236 to 237: returns language', () => {
+    const oldSchema = {
+      ...v235Schema,
+      i18n: {
+        ...v235Schema.i18n,
+        language: undefined,
+      },
+    }
+    const migratedSchema = migrations[237](oldSchema)
+    const expectedSchema: any = _.cloneDeep(oldSchema)
+    expectedSchema.account.onboardingCompleted = false
+    expectedSchema.account.lastOnboardingStepScreen = Screens.Language
+    expectedSchema.identity = _.omit(oldSchema.identity, 'hasSeenVerificationNux')
+    expect(migratedSchema).toStrictEqual(expectedSchema)
+  })
+
+  it('works from 236 to 237: returns welcome if not accepted terms', () => {
+    const oldSchema = {
+      ...v235Schema,
+      account: {
+        ...v235Schema.account,
+        acceptedTerms: false,
+      },
+    }
+    const migratedSchema = migrations[237](oldSchema)
+    const expectedSchema: any = _.cloneDeep(oldSchema)
+    expectedSchema.account.onboardingCompleted = false
+    expectedSchema.account.lastOnboardingStepScreen = Screens.Welcome
+    expectedSchema.identity = _.omit(oldSchema.identity, 'hasSeenVerificationNux')
+    expect(migratedSchema).toStrictEqual(expectedSchema)
+  })
+
+  it('works from 236 to 237: returns welcome if no pincode', () => {
+    const oldSchema = {
+      ...v235Schema,
+      account: {
+        ...v235Schema.account,
+        pincodeType: PincodeType.Unset,
+      },
+    }
+    const migratedSchema = migrations[237](oldSchema)
+    const expectedSchema: any = _.cloneDeep(oldSchema)
+    expectedSchema.account.onboardingCompleted = false
+    expectedSchema.account.lastOnboardingStepScreen = Screens.Welcome
+    expectedSchema.identity = _.omit(oldSchema.identity, 'hasSeenVerificationNux')
+    expect(migratedSchema).toStrictEqual(expectedSchema)
+  })
+
+  it('works from 236 to 237: returns welcome if no account', () => {
+    const oldSchema = {
+      ...v235Schema,
+      web3: {
+        ...v235Schema.web3,
+        account: undefined,
+      },
+    }
+    const migratedSchema = migrations[237](oldSchema)
+    const expectedSchema: any = _.cloneDeep(oldSchema)
+    expectedSchema.account.onboardingCompleted = false
+    expectedSchema.account.lastOnboardingStepScreen = Screens.Welcome
+    expectedSchema.identity = _.omit(oldSchema.identity, 'hasSeenVerificationNux')
+    expect(migratedSchema).toStrictEqual(expectedSchema)
+  })
+
+  it('works from 236 to 237: returns import wallet if no account and restoring', () => {
+    const oldSchema = {
+      ...v235Schema,
+      account: {
+        ...v235Schema.account,
+        choseToRestoreAccount: true,
+        acceptedTerms: true,
+        pincodeType: PincodeType.CustomPin,
+      },
+      web3: {
+        ...v235Schema.web3,
+        account: undefined,
+      },
+    }
+    const migratedSchema = migrations[237](oldSchema)
+    const expectedSchema: any = _.cloneDeep(oldSchema)
+    expectedSchema.account.onboardingCompleted = false
+    expectedSchema.account.lastOnboardingStepScreen = Screens.ImportWallet
+    expectedSchema.identity = _.omit(oldSchema.identity, 'hasSeenVerificationNux')
+    expect(migratedSchema).toStrictEqual(expectedSchema)
+  })
+
+  it('works from 236 to 237: returns import select if no account and restoring and CAB enabled', () => {
+    jest.replaceProperty(
+      ONBOARDING_FEATURES_ENABLED,
+      ToggleableOnboardingFeatures.CloudBackup,
+      true
+    )
+    const oldSchema = {
+      ...v235Schema,
+      account: {
+        ...v235Schema.account,
+        choseToRestoreAccount: true,
+        acceptedTerms: true,
+        pincodeType: PincodeType.CustomPin,
+      },
+      web3: {
+        ...v235Schema.web3,
+        account: undefined,
+      },
+    }
+    const migratedSchema = migrations[237](oldSchema)
+    const expectedSchema: any = _.cloneDeep(oldSchema)
+    expectedSchema.account.onboardingCompleted = false
+    expectedSchema.account.lastOnboardingStepScreen = Screens.ImportSelect
+    expectedSchema.identity = _.omit(oldSchema.identity, 'hasSeenVerificationNux')
+    expect(migratedSchema).toStrictEqual(expectedSchema)
+  })
+
+  it('works from 236 to 237: returns protect wallet if recovery phrase seen but not saved', () => {
+    const oldSchema = {
+      ...v235Schema,
+      account: {
+        ...v235Schema.account,
+        acceptedTerms: true,
+        pincodeType: PincodeType.CustomPin,
+        recoveryPhraseInOnboardingStatus: RecoveryPhraseInOnboardingStatus.InProgress,
+      },
+    }
+    const migratedSchema = migrations[237](oldSchema)
+    const expectedSchema: any = _.cloneDeep(oldSchema)
+    expectedSchema.account.onboardingCompleted = false
+    expectedSchema.account.lastOnboardingStepScreen = Screens.ProtectWallet
+    expectedSchema.identity = _.omit(oldSchema.identity, 'hasSeenVerificationNux')
+    expect(migratedSchema).toStrictEqual(expectedSchema)
+  })
+
+  it('works from 236 to 237: returns PN verification if not seen and enabled', () => {
+    jest.replaceProperty(
+      ONBOARDING_FEATURES_ENABLED,
+      ToggleableOnboardingFeatures.PhoneVerification,
+      true
+    )
+    const oldSchema = {
+      ...v235Schema,
+      account: {
+        ...v235Schema.account,
+        acceptedTerms: true,
+        pincodeType: PincodeType.CustomPin,
+      },
+      identity: {
+        ...v235Schema.identity,
+        hasSeenVerificationNux: false,
+      },
+    }
+    const migratedSchema = migrations[237](oldSchema)
+    const expectedSchema: any = _.cloneDeep(oldSchema)
+    expectedSchema.account.onboardingCompleted = false
+    expectedSchema.account.lastOnboardingStepScreen = Screens.VerificationStartScreen
+    expectedSchema.identity = _.omit(oldSchema.identity, 'hasSeenVerificationNux')
+    expect(migratedSchema).toStrictEqual(expectedSchema)
+  })
+
+  it('works from 236 to 237: returns home if not seen verification but disabled', () => {
+    const oldSchema = {
+      ...v235Schema,
+      account: {
+        ...v235Schema.account,
+        acceptedTerms: true,
+        pincodeType: PincodeType.CustomPin,
+      },
+      identity: {
+        ...v235Schema.identity,
+        hasSeenVerificationNux: false,
+      },
+    }
+    const migratedSchema = migrations[237](oldSchema)
+    const expectedSchema: any = _.cloneDeep(oldSchema)
+    expectedSchema.account.onboardingCompleted = true
+    expectedSchema.account.lastOnboardingStepScreen = Screens.TabNavigator
+    expectedSchema.identity = _.omit(oldSchema.identity, 'hasSeenVerificationNux')
+    expect(migratedSchema).toStrictEqual(expectedSchema)
+  })
+
+  it('works from 251 to 252', () => {
+    const oldSchema = {
+      ...v251Schema,
+    }
+    const migratedSchema = migrations[252](oldSchema)
+    const expectedSchema: any = _.cloneDeep(oldSchema)
+    expectedSchema.jumpstart = _.pick(oldSchema.jumpstart, 'reclaimStatus')
+    expectedSchema.app = _.omit(oldSchema.app, 'inviterAddress')
+    expect(migratedSchema).toStrictEqual(expectedSchema)
+  })
+})