Merge pull request #2164 from AmbireTech/release/v2.88

Release / v2.88.0

Author: superKalo

.github/workflows/tests.yml

@@ -28,9 +28,9 @@ jobs:
         uses: actions/checkout@v3
 
       - name: Install Node.js ⚙️
-        uses: actions/setup-node@v3
+        uses: actions/setup-node@v6
         with:
-          node-version: 22.12.0
+          node-version-file: '.nvmrc'
 
       - name: Install NPM packages ♾️🕳️
         run: npm ci
@@ -47,5 +47,5 @@ jobs:
           REACT_APP_PIMLICO_API_KEY: ${{ secrets.REACT_APP_PIMLICO_API_KEY }}
           REACT_APP_CANDIDE_API_KEY: ${{ secrets.REACT_APP_CANDIDE_API_KEY }}
           REACT_APP_ETHERSPOT_API_KEY: ${{ secrets.REACT_APP_ETHERSPOT_API_KEY }}
-          
+
         run: npm run jest

.nvmrc

@@ -1 +1 @@
-22.12.0
+24.13.0

package.json

@@ -1,5 +1,5 @@
 {
-  "version": "2.87.2",
+  "version": "2.88.3",
   "name": "ambire-common",
   "description": "Common ground for the Ambire apps",
   "scripts": {

src/classes/recurringTimeout/recurringTimeout.test.ts

@@ -102,6 +102,48 @@ describe('RecurringTimeout', () => {
     await jest.advanceTimersByTimeAsync(200)
     expect(fn).toHaveBeenCalledTimes(2)
   })
+  test('should allow overlap when configured: next fn run starts even if previous is running', async () => {
+    // The second call should overlap with the first, but after both complete,
+    // there should be only one scheduled loop
+    const first = createDeferred()
+    const second = createDeferred()
+    const fn = jest
+      .fn()
+      .mockImplementationOnce(() => first.promise)
+      .mockImplementationOnce(() => second.promise)
+
+    const t = new RecurringTimeout(fn, 200)
+    t.start({ runImmediately: true, allowOverlap: true })
+
+    await jest.advanceTimersByTimeAsync(0) // wait for the debounce timeout
+    expect(fn).toHaveBeenCalledTimes(1)
+
+    // Trigger restart while the first is still running
+    // without allowOverlap, this would not schedule a new run
+    t.restart({ runImmediately: true, allowOverlap: true })
+    await jest.advanceTimersByTimeAsync(0) // wait for the debounce timeout
+    expect(fn).toHaveBeenCalledTimes(2)
+
+    // Resolve first
+    first.resolve()
+    await Promise.resolve() // this await the promise of the fn to run its .then/.catch/.finally
+
+    // No new run should be scheduled yet
+    await jest.advanceTimersByTimeAsync(1000)
+    expect(fn).toHaveBeenCalledTimes(2)
+
+    // Resolve second
+    second.resolve()
+    await Promise.resolve() // this await the promise of the fn to run its .then/.catch/.finally
+
+    // Now a new run should be scheduled
+    // Purposefully advance more than 200ms to ensure the timer is not
+    // affected by small inaccuracies
+    await jest.advanceTimersByTimeAsync(300)
+    // Expect 3!!! If there is a bug that makes loop() schedule multiple
+    // timeouts, this will catch it.
+    expect(fn).toHaveBeenCalledTimes(3)
+  })
   test('stop should prevent further fn runs and clears timer', async () => {
     const d1 = createDeferred()
     const fn = jest.fn(() => d1.promise)

src/classes/recurringTimeout/recurringTimeout.ts

@@ -5,9 +5,31 @@
 
 import EventEmitter from '../../controllers/eventEmitter/eventEmitter'
 
+type RecurringTimeoutStartOptions = {
+  timeout?: number
+  /**
+   * Whether to run the function immediately upon starting,
+   * instead of waiting for the first timeout interval.
+   */
+  runImmediately?: boolean
+  /**
+   * Whether to allow the starting of a new function execution
+   * even if the previous one is still running. There will still
+   * be only one interval scheduled at a time.
+   *
+   * @example
+   * - Execution 1 starts
+   * - Execution 2 starts while Execution 1 is still running
+   * - Execution 1 completes - a new execution is not scheduled. Simply
+   * the promise of Execution 1 is resolved.
+   * - Execution 2 completes - a new execution is scheduled.
+   */
+  allowOverlap?: boolean
+}
+
 export interface IRecurringTimeout {
-  start: (options?: { timeout?: number; runImmediately?: boolean }) => void
-  restart: (options?: { timeout?: number; runImmediately?: boolean }) => void
+  start: (options?: RecurringTimeoutStartOptions) => void
+  restart: (options?: RecurringTimeoutStartOptions) => void
   stop: () => void
   updateTimeout: (options: { timeout: number }) => void
   running: boolean
@@ -42,7 +64,7 @@ export class RecurringTimeout implements IRecurringTimeout {
   promise: Promise<void> | undefined
 
   // collapse multiple start/restart calls in the same tick
-  #pendingStart?: { timeout?: number; runImmediately?: boolean }
+  #pendingStart?: RecurringTimeoutStartOptions
 
   startScheduled = false
 
@@ -62,7 +84,7 @@ export class RecurringTimeout implements IRecurringTimeout {
     this.currentTimeout = timeout
   }
 
-  start(opts: { timeout?: number; runImmediately?: boolean } = {}) {
+  start(opts: RecurringTimeoutStartOptions = {}) {
     this.#scheduleStart(opts)
   }
 
@@ -71,43 +93,42 @@ export class RecurringTimeout implements IRecurringTimeout {
     this.#reset()
   }
 
-  restart(opts: { timeout?: number; runImmediately?: boolean } = {}) {
+  restart(opts: RecurringTimeoutStartOptions = {}) {
     this.#reset()
     this.#scheduleStart(opts)
   }
 
   async #loop() {
+    this.fnExecutionsCount += 1
+    const currentCount = this.fnExecutionsCount
+
     try {
       this.promise = this.#fn()
-      this.fnExecutionsCount += 1
       await this.promise
     } catch (err: any) {
       if (!this.promise) return
       console.error('Recurring task error:', err)
       if (this.#emitError)
         this.#emitError({ error: err, message: 'Recurring task failed', level: 'minor' })
     } finally {
-      if (this.promise) {
+      // If fnExecutionsCount has changed, it means `restart` was called during the execution of fn,
+      // so we shouldn't schedule the next loop here.
+      if (this.promise && this.fnExecutionsCount === currentCount) {
         if (this.running) this.#timeoutId = setTimeout(this.#loop.bind(this), this.currentTimeout)
         this.promise = undefined
       }
     }
   }
 
-  #scheduleStart(
-    opts: {
-      timeout?: number
-      runImmediately?: boolean
-    } = {}
-  ) {
+  #scheduleStart(opts: RecurringTimeoutStartOptions = {}) {
     if (this.running) return
     this.#pendingStart = opts // collect latest opts for this tick
     if (this.startScheduled) return
     this.startScheduled = true
 
     queueMicrotask(() => {
       this.startScheduled = false
-      const { timeout: newTimeout, runImmediately } = this.#pendingStart || {}
+      const { timeout: newTimeout, runImmediately, allowOverlap } = this.#pendingStart || {}
       this.#pendingStart = undefined
 
       this.running = true
@@ -116,7 +137,8 @@ export class RecurringTimeout implements IRecurringTimeout {
 
       if (newTimeout) this.updateTimeout({ timeout: newTimeout })
 
-      if (this.promise) return // prevents multiple executions in one tick
+      // Prevents starting a new loop if the previous one is still running
+      if (this.promise && !allowOverlap) return
 
       if (runImmediately) {
         this.#loop()

src/consts/coingecko.ts

@@ -1,7 +1,7 @@
 import { ZeroAddress } from 'ethers'
 
 import { Network } from '../interfaces/network'
-import { WALLET_STAKING_ADDR, WALLET_TOKEN } from './addresses'
+import { STK_WALLET, WALLET_STAKING_ADDR, WALLET_TOKEN } from './addresses'
 
 const COINGECKO_API_BASE_URL = 'https://api.coingecko.com/api/v3/coins/'
 const COINGECKO_BASE_URL = 'https://www.coingecko.com/en/coins/'
@@ -21,8 +21,8 @@ export function geckoIdMapper(address: string, network: Network): string | null
  * CoinGecko (so that they are aliased to existing tokens).
  */
 export function geckoTokenAddressMapper(address: string) {
-  // xWALLET is missing on CoinGecko, so alias it to WALLET token (that exists on CoinGecko)
-  if (address === WALLET_STAKING_ADDR) return WALLET_TOKEN
+  // stkWALLET and xWALLET are missing on CoinGecko, so alias to WALLET token (which exists)
+  if ([STK_WALLET, WALLET_STAKING_ADDR].includes(address)) return WALLET_TOKEN
 
   return address
 }

src/consts/dapps/dapps.ts

@@ -13,6 +13,8 @@ export const dappIdsToBeRemoved = new Set([
   'curve.fi', // curve.fi was moved to curve.finance
   'app.ether.fi', // app.ether.fi was moved to ether.fi
   'core.app', // not supported,
+  'new.bungee.exchange', // got left hanging since Bungee moved to bungee.exchange
+  'multitx.bungee.exchange', // got left hanging since Bungee moved to bungee.exchange
   // unsupported or outdated protocols returned by DefiLlama
   'bridge.base.org',
   'binance.com',
@@ -419,7 +421,7 @@ export const defiLlamaProtocolIdsToExclude: string[] = [
 
 export const categoriesNotToFilterOut = ['DEX Aggregator']
 export const categoriesToExclude = ['CEX', 'Developer Tools']
-export const dappsNotToFilterOutByDomain = ['snapshot.box']
+export const dappsNotToFilterOutByDomain = ['snapshot.box', 'bungee.exchange']
 
 export const CATEGORY_MAP: Record<string, string> = {
   'AI Agents': 'AI Agents',

src/controllers/accountPicker/accountPicker.test.ts

@@ -15,13 +15,11 @@ import {
   DERIVATION_OPTIONS,
   SMART_ACCOUNT_SIGNER_KEY_DERIVATION_OFFSET
 } from '../../consts/derivation'
-import { networks } from '../../consts/networks'
 import { Account } from '../../interfaces/account'
 import { IProvidersController } from '../../interfaces/provider'
 import { Storage } from '../../interfaces/storage'
 import { isSmartAccount } from '../../libs/account/account'
 import { getPrivateKeyFromSeed, KeyIterator } from '../../libs/keyIterator/keyIterator'
-import { getRpcProvider } from '../../services/provider'
 import wait from '../../utils/wait'
 import { AccountsController } from '../accounts/accounts'
 import { KeystoreController } from '../keystore/keystore'
@@ -73,22 +71,15 @@ const prepareTest = async () => {
     storage: storageCtrl,
     fetch,
     relayerUrl,
-    onAddOrUpdateNetworks: (nets) => {
-      nets.forEach((n) => {
-        providersCtrl.setProvider(n)
-      })
+    useTempProvider: (props, cb) => {
+      return providersCtrl.useTempProvider(props, cb)
     },
-    onRemoveNetwork: (id) => {
-      providersCtrl.removeProvider(id)
-    }
+    onAddOrUpdateNetworks: () => {}
   })
-  providersCtrl = new ProvidersController(networksCtrl, storageCtrl)
-
-  providersCtrl.providers = Object.fromEntries(
-    networks.map((network) => [network.chainId, getRpcProvider(network.rpcUrls, network.chainId)])
-  )
   const { uiManager } = mockUiManager()
   const uiCtrl = new UiController({ uiManager })
+  providersCtrl = new ProvidersController(networksCtrl, storageCtrl, uiCtrl)
+
   const keystoreController = new KeystoreController('default', storageCtrl, {}, uiCtrl)
 
   const accountsCtrl = new AccountsController(