fix: grouped 2 functions in one and changed varaible naming on tests

aragon · Feb 27, 2024 · 5d1dca0 · 5d1dca0
1 parent c05ec62
commit 5d1dca0
Show file tree

Hide file tree

Showing 2 changed files with 34 additions and 50 deletions.
diff --git a/sdk/src/ens/utils.ts b/sdk/src/ens/utils.ts
@@ -14,30 +14,24 @@ import {JsonRpcProvider} from '@ethersproject/providers';
  */
 export function resolveEnsName(
   ensName: string,
-  provider: JsonRpcProvider
+  providerOrNetwork: JsonRpcProvider | Networkish
 ): Promise<string | null> {
+  // check if the ensName is valid
   if (!isEnsName(ensName)) {
     throw new InvalidEnsError(ensName);
   }
-  return provider.resolveName(ensName);
-}
-
-/**
- * Resolves an ENS name to an address given a network
- *
- * @export
- * @param {string} ensName
- * @param {Networkish} network
- * @return {(Promise<string | null>)}
- */
-export function resolveEnsNameWithProvider(
-  ensName: string,
-  network: Networkish
-): Promise<string | null> {
-  const aragonNetwork = getNetworkByAlias(network.toString());
-  if (!aragonNetwork) {
-    throw new UnsupportedNetworkError(network.toString());
+  let provider: JsonRpcProvider;
+  // check if the providerOrNetwork is a provider or a network
+  // if it's a provider, use it
+  if (providerOrNetwork instanceof JsonRpcProvider) {
+    provider = providerOrNetwork;
+  // any other case, assume it's a network and create a provider
+  } else {
+    const aragonNetwork = getNetworkByAlias(providerOrNetwork.toString());
+    if (!aragonNetwork) {
+      throw new UnsupportedNetworkError(providerOrNetwork.toString());
+    }
+    provider = new JsonRpcProvider(aragonNetwork.url, providerOrNetwork);
   }
-  const provider = new JsonRpcProvider(aragonNetwork.url, network);
-  return resolveEnsName(ensName, provider);
+  return provider.resolveName(ensName);
 }
diff --git a/sdk/test/unit/ens.test.ts b/sdk/test/unit/ens.test.ts
@@ -1,15 +1,11 @@
-import {
-  InvalidEnsError,
-  resolveEnsName,
-  resolveEnsNameWithProvider,
-} from '../../src';
+import {InvalidEnsError, resolveEnsName} from '../../src';
 import {ADDRESS_ONE, TEST_ENS_NAME, TEST_HTTP_URI} from '../constants';
 import {JsonRpcProvider} from '@ethersproject/providers';
 
 describe('ens', () => {
   describe('resolveEnsName', () => {
-    it('should return the correct value', async () => {
-      const inputs = [
+    it('should receive a JsonRpcProvider and return the correct value', async () => {
+      const tests = [
         {
           input: TEST_ENS_NAME,
           network: 'mainnet',
@@ -22,24 +18,22 @@ describe('ens', () => {
           error: new InvalidEnsError(TEST_HTTP_URI),
         },
       ];
-      for (const input of inputs) {
+      for (const test of tests) {
         // mocked provider
         const provider = new JsonRpcProvider();
-        if (input.error) {
+        if (test.error) {
           await expect(
-            async () => await resolveEnsName(input.input, provider)
-          ).rejects.toThrow(input.error);
+            async () => await resolveEnsName(test.input, provider)
+          ).rejects.toThrow(test.error);
           continue;
         }
-        jest.spyOn(provider, 'resolveName').mockResolvedValue(input.output);
-        const resolvedAddress = await resolveEnsName(input.input, provider);
-        expect(resolvedAddress).toEqual(input.output);
+        jest.spyOn(provider, 'resolveName').mockResolvedValue(test.output);
+        const resolvedAddress = await resolveEnsName(test.input, provider);
+        expect(resolvedAddress).toEqual(test.output);
       }
     });
-  });
-  describe('resolveEnsNameWithProvider', () => {
-    it('should return the correct value', async () => {
-      const inputs = [
+    it('should receive a Networkish and return the correct value', async () => {
+      const tests = [
         {
           input: TEST_ENS_NAME,
           network: 'mainnet',
@@ -52,23 +46,19 @@ describe('ens', () => {
           error: new InvalidEnsError(TEST_HTTP_URI),
         },
       ];
-      for (const input of inputs) {
+      for (const test of tests) {
         // mocked provider
-        if (input.error) {
+        if (test.error) {
           await expect(
-            async () =>
-              await resolveEnsNameWithProvider(input.input, input.network)
-          ).rejects.toThrow(input.error);
+            async () => await resolveEnsName(test.input, test.network)
+          ).rejects.toThrow(test.error);
           continue;
         }
         jest
           .spyOn(JsonRpcProvider.prototype, 'resolveName')
-          .mockResolvedValue(input.output);
-        const resolvedAddress = await resolveEnsNameWithProvider(
-          input.input,
-          input.network
-        );
-        expect(resolvedAddress).toEqual(input.output);
+          .mockResolvedValue(test.output);
+        const resolvedAddress = await resolveEnsName(test.input, test.network);
+        expect(resolvedAddress).toEqual(test.output);
       }
     });
   });