refactor abi mapper for graceful options

Author: refcell

src/AbiMapper.ts

@@ -0,0 +1,172 @@
+import { Interface } from '@ethersproject/abi';
+import { multicall1, multicall2, multicall3 } from './abis';
+import { Options } from './models';
+import { networks } from './networks';
+import { Address, Mapping, Network } from './types';
+
+// Checks if the provided address is a valid multicall address in our network definitions
+const constructWithAddress = (address: Address): Mapping => {
+  let mapping: Mapping = {
+    found: false,
+    address: networks['1']['multicall3'],
+    network: 1,
+    interface: new Interface(multicall3),
+    abi: multicall3,
+  };
+
+  // Iterate over the networks
+  for (const network in networks) {
+    // If we have a match, return the network
+    const networkObject: Mapping = networkToMapping(
+      parseInt(network),
+      networks[network],
+      address
+    );
+    if (networkObject.found) {
+      mapping = networkObject;
+      break;
+    }
+  }
+
+  return mapping;
+};
+
+// Attempts to construct a mapping from a network object with the provided multicall address
+const networkToMapping = (
+  network: Network,
+  networkObject: object,
+  address: Address
+): Mapping => {
+  let mapping: Mapping = {
+    found: false,
+    address: networks['1']['multicall3'],
+    network: 1,
+    interface: new Interface(multicall3),
+    abi: multicall3,
+  };
+
+  if (networkObject['multicall3'].toLowerCase() == address.toLowerCase()) {
+    mapping = {
+      found: true,
+      address: networkObject['multicall3'],
+      network,
+      interface: new Interface(multicall3),
+      abi: multicall3,
+    };
+  } else if (
+    networkObject['multicall2'].toLowerCase() == address.toLowerCase()
+  ) {
+    mapping = {
+      found: true,
+      address: networkObject['multicall2'],
+      network,
+      interface: new Interface(multicall2),
+      abi: multicall2,
+    };
+  } else if (
+    networkObject['multicall'].toLowerCase() == address.toLowerCase()
+  ) {
+    mapping = {
+      found: true,
+      address: networks[network.toString()]['multicall'],
+      network,
+      interface: new Interface(multicall1),
+      abi: multicall1,
+    };
+  }
+
+  return mapping;
+};
+
+// Maps Multicall address string to an Interface generated from our stored ABIs
+// Network defaults to 1 (mainnet) if multicall address isn't found
+// If an inconsistency is found between the network and multicall address string,
+//  the multicall address is first checked, then we will default to the multicall
+//  instance of the provided network
+const abiMap = (options?: Options): Mapping => {
+  // Craft the default mapping
+  let mapping: Mapping = {
+    found: false,
+    address: networks['1']['multicall3'],
+    network: 1,
+    interface: new Interface(multicall3),
+    abi: multicall3,
+  };
+
+  // If we have options
+  if (options) {
+    // Deconstruct our option parameters
+    const { multicall: address, network } = options;
+
+    if (network) {
+      const networkObject: object = networks[network.toString()];
+
+      // If we have a network, let's check if we have a multicall address
+      if (networkObject) {
+        // Try to get multicall with address
+        const foundMulticall = networkToMapping(
+          network,
+          networkObject,
+          address || '0x0' // if no address, 0x0 shouldn't work
+        );
+        if (foundMulticall.found) {
+          mapping = foundMulticall;
+        } else {
+          // The network didn't contain the expected multicall address
+          // Check if networks contains the address
+          const validatedNetwork: Mapping = constructWithAddress(
+            address || '0x0'
+          );
+
+          // If the address isn't found, we can use the network
+          if (!validatedNetwork.found) {
+            // Grab the most up to date multicall address
+            if (networkObject['multicall3']) {
+              mapping = {
+                found: true,
+                address: networkObject['multicall3'],
+                network,
+                interface: new Interface(multicall3),
+                abi: multicall3,
+              };
+            } else if (networkObject['multicall2']) {
+              mapping = {
+                found: true,
+                address: networkObject['multicall2'],
+                network,
+                interface: new Interface(multicall2),
+                abi: multicall2,
+              };
+            } else if (networkObject['multicall1']) {
+              mapping = {
+                found: true,
+                address: networkObject['multicall1'],
+                network,
+                interface: new Interface(multicall1),
+                abi: multicall1,
+              };
+            } else {
+              // We have to use the default since none of the network multicalls are defined
+              // This should really never happen
+            }
+          } else {
+            // Otherwise, use the address
+            mapping = validatedNetwork;
+          }
+        }
+      } else {
+        // No network, try to find multicall address and use it
+        mapping = constructWithAddress(address || '0x0');
+      }
+    } else {
+      // No network, try to find multicall address and use it
+      mapping = constructWithAddress(address || '0x0');
+    }
+  }
+
+  // Return the constructed mapping
+  return mapping;
+};
+
+export default abiMap;
+export { Mapping, abiMap, constructWithAddress, networkToMapping };

src/Multicall.ts

@@ -6,9 +6,10 @@ import {
   AggregatedCall,
   AggregateFullResponse,
   ContractCall,
+  Options,
 } from './models';
-
-type Address = string;
+import abiMap, { Mapping } from 'AbiMapper';
+import { Address, Network } from './types';
 
 // Multicall - A library for calling multiple contracts in aggregate
 export class Multicall {
@@ -21,7 +22,7 @@ export class Multicall {
   constructor(options?: {
     address?: Address;
     provider?: ethers.providers.Provider | ethers.Signer;
-    network?: number;
+    network?: Network;
   }) {
     // Extract the network or default to 1
     this.chainId = options && options.network ? options.network : 1;
@@ -251,13 +252,14 @@ export class Multicall {
   }
 
   public static async call(
-    calls: ContractCall[] | ContractCall
+    calls: ContractCall[] | ContractCall,
+    options?: Options
   ): Promise<AggregateFullResponse> {
     // Encode the calls
     const encoded: AggregatedCall[] = Multicall.encode(calls);
 
     // Craft default configuration
-    const abi: object = multicall3;
+    const abi: Mapping = abiMap(options);
     const multicall3Address: string = networks['1']['multicall3'];
     const provider: ethers.providers.Provider | ethers.Signer =
       ethers.getDefaultProvider();

src/index.ts

@@ -1 +1,3 @@
 export { Multicall } from './Multicall';
+export * from './types';
+export * from './AbiMapper';

src/models/Options.ts

@@ -0,0 +1,8 @@
+import { ethers } from 'ethers';
+
+export interface Options {
+  abi?: any[];
+  multicall?: string;
+  provider?: ethers.providers.Provider | ethers.Signer;
+  network?: number;
+}

src/models/index.ts

@@ -4,6 +4,7 @@ import { AggregateFullResponse } from './AggregateFullResponse';
 import { AggregatedCall } from './AggregatedCall';
 import { ContractCall } from './ContractCall';
 import { SingleCall } from './SingleCall';
+import { Options } from './Options';
 
 // Re-exports
 export {
@@ -12,5 +13,6 @@ export {
   AggregatedCall,
   ContractCall,
   SingleCall,
+  Options,
 };
 export default {};

src/types.ts

@@ -0,0 +1,12 @@
+import { Interface } from 'ethers/lib/utils';
+
+export type Network = number;
+export type Address = string;
+
+export interface Mapping {
+  found: boolean;
+  address: Address;
+  network: Network;
+  interface: Interface;
+  abi: object;
+}

tests/AbiMapper.test.ts

@@ -0,0 +1,46 @@
+import { multicall1, multicall2, multicall3 } from '../src/abis';
+import { networks } from '../src/networks';
+import { Address, Mapping } from '../src/types';
+import { constructWithAddress } from '../src';
+
+describe('Constructs Mapping with Address', () => {
+  it('Non-existent address returns default mapping', () => {
+    const zero: Address = '0x0000000000000000000000000000000000000000';
+    const mapping: Mapping = constructWithAddress(zero);
+
+    expect(mapping.found).toBe(false);
+    expect(mapping.address).toEqual(networks['1']['multicall3']);
+    expect(mapping.network).toEqual(1);
+    expect(mapping.abi).toEqual(multicall3);
+  });
+
+  it('Existing Multicall 3 properly construct mappings', () => {
+    const goerliMulticall3: Address = networks['5']['multicall3'];
+    const mapping: Mapping = constructWithAddress(goerliMulticall3);
+
+    expect(mapping.found).toBe(true);
+    expect(mapping.address).toEqual(goerliMulticall3);
+    expect(mapping.network).toEqual(5);
+    expect(mapping.abi).toEqual(multicall3);
+  });
+
+  it('Existing Multicall 2 properly construct mappings', () => {
+    const rinkebyMulticall2: Address = networks['4']['multicall2'];
+    const mapping: Mapping = constructWithAddress(rinkebyMulticall2);
+
+    expect(mapping.found).toBe(true);
+    expect(mapping.address).toEqual(rinkebyMulticall2);
+    expect(mapping.network).toEqual(4);
+    expect(mapping.abi).toEqual(multicall2);
+  });
+
+  it('Existing Multicall 1 properly construct mappings', () => {
+    const ropstenMulticall1: Address = networks['3']['multicall1'];
+    const mapping: Mapping = constructWithAddress(ropstenMulticall1);
+
+    expect(mapping.found).toBe(true);
+    expect(mapping.address).toEqual(ropstenMulticall1);
+    expect(mapping.network).toEqual(3);
+    expect(mapping.abi).toEqual(multicall1);
+  });
+});