feat: Get Sentinel URL and supported chain IDs dynamically

src/SmartTransactionsController.test.ts

@@ -415,7 +415,7 @@
       await withController(
         {
           options: {
-            supportedChainIds: [ChainId.mainnet],
+            getSupportedChainIds: () => [ChainId.mainnet],
           },
         },
         ({ controller, triggerNetworStateChange }) => {
@@ -446,7 +446,7 @@
 
         controller.timeoutHandle = setTimeout(() => ({}));
 
         controller.poll(1000);
 
         expect(updateSmartTransactionsSpy).toHaveBeenCalled();
       });
@@ -1141,6 +1141,26 @@
       });
     });
 
+    it('fetches liveness using custom getSentinelUrl', async () => {
+      const customSentinelUrl = 'https://custom-sentinel.example.com';
+      await withController(
+        {
+          options: {
+            getSentinelUrl: (_chainId: Hex) => customSentinelUrl,
+          },
+        },
+        async ({ controller }) => {
+          nock(customSentinelUrl)
+            .get(`/network`)
+            .reply(200, createSuccessLivenessApiResponse());
+
+          const liveness = await controller.fetchLiveness();
+
+          expect(liveness).toBe(true);
+        },
+      );
+    });
+
     it('fetches liveness and sets in feesByChainId state for the Smart Transactions API for the chainId of the networkClientId passed in', async () => {
       await withController(async ({ controller }) => {
         nock(SENTINEL_API_BASE_URL_MAP[sepoliaChainIdDec])
@@ -1869,7 +1889,7 @@
       await withController(
         {
           options: {
-            // pending transactions in state are required to test polling
+            getSupportedChainIds: () => [ChainId.mainnet, ChainId.sepolia],
             state: {
               smartTransactionsState: {
                 ...getDefaultSmartTransactionsControllerState()
@@ -1989,7 +2009,7 @@
       await withController(
         {
           options: {
-            // pending transactions in state are required to test polling
+            getSupportedChainIds: () => [ChainId.mainnet],
             state: {
               smartTransactionsState: {
                 ...getDefaultSmartTransactionsControllerState()
@@ -2166,12 +2186,10 @@
       );
     });
 
-    it('removes transactions from the current chainId (even if it is not in supportedChainIds) if ignoreNetwork is false', async () => {
+    it('removes transactions from the current chainId (even if it is not returned by getSupportedChainIds) if ignoreNetwork is false', async () => {
       await withController(
         {
           options: {
-            supportedChainIds: [ChainId.sepolia],
-            chainId: ChainId.mainnet,
             state: {
               smartTransactionsState: {
                 ...getDefaultSmartTransactionsControllerState()
@@ -2218,11 +2236,11 @@
       );
     });
 
-    it('removes transactions from all chains (even if they are not in supportedChainIds) if ignoreNetwork is true', async () => {
+    it('removes transactions from all chains (even if they are not returned by getSupportedChainIds) if ignoreNetwork is true', async () => {
       await withController(
         {
           options: {
-            supportedChainIds: [],
+            getSupportedChainIds: () => [],
             state: {
               smartTransactionsState: {
                 ...getDefaultSmartTransactionsControllerState()
@@ -2703,7 +2721,7 @@
       triggerNetworStateChange,
     });
   } finally {
     controller.stop();
     controller.stopAllPolling();
   }
 }

src/SmartTransactionsController.ts

@@ -191,7 +191,6 @@
   interval?: number;
   clientId: ClientId;
   chainId?: Hex;
-  supportedChainIds?: Hex[];
   getNonceLock: TransactionController['getNonceLock'];
   confirmExternalTransaction: TransactionController['confirmExternalTransaction'];
   trackMetaMetricsEvent: (
@@ -212,6 +211,8 @@
   getFeatureFlags: () => FeatureFlags;
   updateTransaction: (transaction: TransactionMeta, note: string) => void;
   trace?: TraceCallback;
+  getSentinelUrl?: (chainId: Hex) => string | undefined;
+  getSupportedChainIds?: () => Hex[];
 };
 
 export type SmartTransactionsControllerPollingInput = {
@@ -229,8 +230,6 @@
 
   #chainId: Hex;
 
-  #supportedChainIds: Hex[];
-
   timeoutHandle?: NodeJS.Timeout;
 
   readonly #getNonceLock: SmartTransactionsControllerOptions['getNonceLock'];
@@ -253,6 +252,10 @@
 
   #trace: TraceCallback;
 
+  #getSentinelUrl?: SmartTransactionsControllerOptions['getSentinelUrl'];
+
+  #getSupportedChainIds: () => Hex[];
+
   /* istanbul ignore next */
   async #fetch(request: string, options?: RequestInit) {
     const fetchOptions = {
@@ -270,7 +273,6 @@
     interval = DEFAULT_INTERVAL,
     clientId,
     chainId: InitialChainId = ChainId.mainnet,
-    supportedChainIds = [ChainId.mainnet, ChainId.sepolia],
     getNonceLock,
     confirmExternalTransaction,
     trackMetaMetricsEvent,
@@ -281,6 +283,8 @@
     getFeatureFlags,
     updateTransaction,
     trace,
+    getSentinelUrl,
+    getSupportedChainIds = () => [ChainId.mainnet, ChainId.sepolia],
   }: SmartTransactionsControllerOptions) {
     super({
       name: controllerName,
@@ -294,7 +298,6 @@
     this.#interval = interval;
     this.#clientId = clientId;
     this.#chainId = InitialChainId;
-    this.#supportedChainIds = supportedChainIds;
     this.setIntervalLength(interval);
     this.#getNonceLock = getNonceLock;
     this.#ethQuery = undefined;
@@ -305,6 +308,8 @@
     this.#getFeatureFlags = getFeatureFlags;
     this.#updateTransaction = updateTransaction;
     this.#trace = trace ?? (((_request, fn) => fn?.()) as TraceCallback);
+    this.#getSentinelUrl = getSentinelUrl;
+    this.#getSupportedChainIds = getSupportedChainIds;
 
     this.initializeSmartTransactionsForChainId();
 
@@ -339,7 +344,7 @@
     // wondering if we should add some kind of predicate to the polling controller to check whether
     // we should poll or not
     const filteredChainIds = (chainIds ?? []).filter((chainId) =>
-      this.#supportedChainIds.includes(chainId),
+      this.#getSupportedChainIds().includes(chainId),
     );
 
     if (filteredChainIds.length === 0) {
@@ -358,14 +363,14 @@
       isSmartTransactionPending,
     );
     if (!this.timeoutHandle && pendingTransactions?.length > 0) {
       this.poll();
     } else if (this.timeoutHandle && pendingTransactions?.length === 0) {
       this.stop();
     }
   }
 
   initializeSmartTransactionsForChainId() {
-    if (this.#supportedChainIds.includes(this.#chainId)) {
+    if (this.#getSupportedChainIds().includes(this.#chainId)) {
       this.update((state) => {
         state.smartTransactionsState.smartTransactions[this.#chainId] =
           state.smartTransactionsState.smartTransactions[this.#chainId] ?? [];
@@ -380,12 +385,12 @@
 
     this.timeoutHandle && clearInterval(this.timeoutHandle);
 
-    if (!this.#supportedChainIds.includes(this.#chainId)) {
+    if (!this.#getSupportedChainIds().includes(this.#chainId)) {
       return;
     }
 
     this.timeoutHandle = setInterval(() => {
       safelyExecute(async () => this.updateSmartTransactions());
     }, this.#interval);
     await safelyExecute(async () => this.updateSmartTransactions());
   }
@@ -452,7 +457,7 @@
       ethQuery = new EthQuery(provider);
     }
 
     this.#createOrUpdateSmartTransaction(smartTransaction, {
       chainId,
       ethQuery,
     });
@@ -739,7 +744,7 @@
             : originalTxMeta;
 
         if (this.#doesTransactionNeedConfirmation(txHash)) {
           this.#confirmExternalTransaction(
             // TODO: Replace 'as' assertion with correct typing for `txMeta`
             txMeta as TransactionMeta,
             transactionReceipt,
@@ -1059,7 +1064,7 @@
     );
     return Object.keys(networkConfigurationsByChainId).filter(
       (chainId): chainId is Hex =>
-        this.#supportedChainIds.includes(chainId as Hex),
+        this.#getSupportedChainIds().includes(chainId as Hex),
     );
   }
 
@@ -1122,14 +1127,18 @@
     const chainId = this.#getChainId({ networkClientId });
     let liveness = false;
     try {
+      const url = getAPIRequestURL(
+        APIType.LIVENESS,
+        chainId,
+        this.#getSentinelUrl?.(chainId),
+      );
       const response = await this.#trace(
         { name: SmartTransactionsTraceName.FetchLiveness },
-        async () =>
-          await this.#fetch(getAPIRequestURL(APIType.LIVENESS, chainId)),
+        async () => await this.#fetch(url),
       );
       liveness = Boolean(response.smartTransactions);
     } catch (error) {
-      console.log('"fetchLiveness" API call failed');
+      console.error('"fetchLiveness" API call failed:', error);
     }
 
     this.update((state) => {

src/utils.test.ts

@@ -621,4 +621,24 @@
       expect(updateTransactionMock).not.toHaveBeenCalled();
     });
   });
+
+  describe('getSentinelBaseUrl', () => {
+    it('returns the correct base URL for Ethereum Mainnet', () => {
+      const chainId = ChainId.mainnet;
+      const result = utils.getSentinelBaseUrl(chainId);
+      expect(result).toBe(SENTINEL_API_BASE_URL_MAP[parseInt(ChainId.mainnet, 16)]);
+    });
+
+    it('returns the correct base URL for Sepolia', () => {
+      const chainId = ChainId.sepolia;
+      const result = utils.getSentinelBaseUrl(chainId);
+      expect(result).toBe(SENTINEL_API_BASE_URL_MAP[parseInt(ChainId.sepolia, 16)]);
+    });
+
+    it('returns undefined for unsupported chainId', () => {
+      const unsupportedChainId = '0x999'; // Arbitrary unsupported chain
+      const result = utils.getSentinelBaseUrl(unsupportedChainId);
+      expect(result).toBeUndefined();
+    });
+  });
 });

src/utils.ts

@@ -36,39 +36,48 @@
 ) => stxStatus === 'uuid_not_found';
 
 // TODO use actual url once API is defined
-export function getAPIRequestURL(apiType: APIType, chainId: string): string {
+export function getAPIRequestURL(
+  apiType: APIType,
+  chainId: string,
+  sentinelUrl?: string,
+): string {
   const chainIdDec = parseInt(chainId, 16);
   switch (apiType) {
+    case APIType.LIVENESS: {
+      const effectiveSentinelUrl: string | undefined =
+        sentinelUrl ?? getSentinelBaseUrl(chainId);
+
+      if (effectiveSentinelUrl === undefined) {
+        throw new Error(`No sentinel URL for chainId ${chainId}`);
+      }
+      return `${effectiveSentinelUrl}/network`;
+    }
     case APIType.GET_FEES: {
       return `${API_BASE_URL}/networks/${chainIdDec}/getFees`;
     }
-
     case APIType.ESTIMATE_GAS: {
       return `${API_BASE_URL}/networks/${chainIdDec}/estimateGas`;
     }
-
     case APIType.SUBMIT_TRANSACTIONS: {
       return `${API_BASE_URL}/networks/${chainIdDec}/submitTransactions?stxControllerVersion=${packageJson.version}`;
     }
-
     case APIType.CANCEL: {
       return `${API_BASE_URL}/networks/${chainIdDec}/cancel`;
     }
-
     case APIType.BATCH_STATUS: {
       return `${API_BASE_URL}/networks/${chainIdDec}/batchStatus`;
     }
-
-    case APIType.LIVENESS: {
-      return `${SENTINEL_API_BASE_URL_MAP[chainIdDec]}/network`;
-    }
-
     default: {
-      throw new Error(`Invalid APIType`); // It can never get here thanks to TypeScript.
+      throw new Error(`Invalid APIType`);
     }
   }
 }
 
+export function getSentinelBaseUrl(chainId: string): string | undefined {
+  const chainIdDec = parseInt(chainId, 16);
+  return SENTINEL_API_BASE_URL_MAP[chainIdDec];
+}
+
 export const calculateStatus = (stxStatus: SmartTransactionsStatus) => {
   if (isSmartTransactionStatusResolved(stxStatus)) {
     return SmartTransactionStatuses.RESOLVED;
@@ -343,8 +352,8 @@
     status: TransactionStatus.failed,
     error: {
       name: 'SmartTransactionFailed',
       message: `Smart transaction failed with status: ${status}`,
     },
   };
   updateTransaction(updatedTransaction, `Smart transaction status: ${status}`);
 };