@snapshot-labs/snapshot.js 0.13.0 → 0.14.0

package/src/utils/provider.ts

@@ -1,52 +1,99 @@
-import {
-  JsonRpcBatchProvider,
-  StaticJsonRpcProvider
-} from '@ethersproject/providers';
+import { StaticJsonRpcProvider } from '@ethersproject/providers';
+import { RpcProvider } from 'starknet';
+import networks from '../networks.json';
 
-const providers = {};
-const batchedProviders = {};
+export interface ProviderOptions {
+  readonly broviderUrl?: string;
+  readonly timeout?: number;
+}
+
+type ProviderInstance = StaticJsonRpcProvider | RpcProvider;
+
+type ProviderType = 'evm' | 'starknet';
+
+const DEFAULT_BROVIDER_URL = 'https://rpc.snapshot.org' as const;
+const DEFAULT_TIMEOUT = 25000 as const;
+const STARKNET_BROVIDER_KEYS: string[] = ['sn', 'sn-sep'] as const;
+
+const providerMemo = new Map<string, ProviderInstance>();
 
-export type ProviderOptions = {
-  broviderUrl?: string;
-  timeout?: number;
+const providerFnMap: Record<
+  ProviderType,
+  (networkId: string, options: Required<ProviderOptions>) => ProviderInstance
+> = {
+  evm: getEvmProvider,
+  starknet: getStarknetProvider
 };
 
-const DEFAULT_BROVIDER_URL = 'https://rpc.snapshot.org';
-const DEFAULT_TIMEOUT = 25000;
+function normalizeOptions(
+  options: ProviderOptions = {}
+): Required<ProviderOptions> {
+  return {
+    broviderUrl: options.broviderUrl || DEFAULT_BROVIDER_URL,
+    timeout: options.timeout ?? DEFAULT_TIMEOUT
+  };
+}
+
+function getBroviderNetworkId(network: string | number): string {
+  const config = networks[network];
+  if (!config) {
+    throw new Error(`Network '${network}' is not supported`);
+  }
+  return String(config.key);
+}
+
+function getProviderType(networkId: string): ProviderType {
+  const isStarknet = STARKNET_BROVIDER_KEYS.includes(networkId);
+  return isStarknet ? 'starknet' : 'evm';
+}
 
+function createMemoKey(
+  networkId: string,
+  options: Required<ProviderOptions>
+): string {
+  return `${networkId}:${options.broviderUrl}:${options.timeout}`;
+}
+
+// return loose `any` type to avoid typecheck issues on package consumers
 export default function getProvider(
-  network,
-  {
-    broviderUrl = DEFAULT_BROVIDER_URL,
-    timeout = DEFAULT_TIMEOUT
-  }: ProviderOptions = {}
-) {
-  const url = `${broviderUrl}/${network}`;
-  if (!providers[network])
-    providers[network] = new StaticJsonRpcProvider(
-      {
-        url,
-        timeout,
-        allowGzip: true
-      },
-      Number(network)
-    );
-  return providers[network];
-}
-
-export function getBatchedProvider(
-  network,
-  {
-    broviderUrl = DEFAULT_BROVIDER_URL,
-    timeout = DEFAULT_TIMEOUT
-  }: ProviderOptions = {}
-) {
-  const url = `${broviderUrl}/${network}`;
-  if (!batchedProviders[network])
-    batchedProviders[network] = new JsonRpcBatchProvider({
-      url,
-      timeout,
+  network: string | number,
+  options: ProviderOptions = {}
+): any {
+  const networkId = getBroviderNetworkId(network);
+  const normalizedOptions = normalizeOptions(options);
+  const memoKey = createMemoKey(networkId, normalizedOptions);
+
+  const memoized = providerMemo.get(memoKey);
+  if (memoized) {
+    return memoized;
+  }
+
+  const providerType = getProviderType(networkId);
+  const provider = providerFnMap[providerType](networkId, normalizedOptions);
+
+  providerMemo.set(memoKey, provider);
+  return provider;
+}
+
+function getEvmProvider(
+  networkId: string,
+  options: Required<ProviderOptions>
+): StaticJsonRpcProvider {
+  return new StaticJsonRpcProvider(
+    {
+      url: `${options.broviderUrl}/${networkId}`,
+      timeout: options.timeout,
       allowGzip: true
-    });
-  return batchedProviders[network];
+    },
+    Number(networkId)
+  );
+}
+
+function getStarknetProvider(
+  networkKey: string,
+  options: Required<ProviderOptions>
+): RpcProvider {
+  return new RpcProvider({
+    nodeUrl: `${options.broviderUrl}/${networkKey}`
+  });
 }

package/src/utils.spec.js

@@ -505,66 +505,267 @@ describe('utils', () => {
 
   describe('getFormattedAddress', () => {
     describe('when explicitly passing an address type', () => {
-      test('returns a checksummed EVM address', () => {
-        const address = '0x91fd2c8d24767db4ece7069aa27832ffaf8590f3';
-        expect(getFormattedAddress(address, 'evm')).toEqual(
-          '0x91FD2c8d24767db4Ece7069AA27832ffaf8590f3'
-        );
-      });
+      describe('EVM type parsing', () => {
+        test('should return checksummed EVM address when given checksummed input', () => {
+          const address = '0x91FD2c8d24767db4Ece7069AA27832ffaf8590f3';
+          expect(getFormattedAddress(address, 'evm')).toEqual(
+            '0x91FD2c8d24767db4Ece7069AA27832ffaf8590f3'
+          );
+        });
 
-      test('returns a padded and lowercased starknet address', () => {
-        const address =
-          '0x2a0a8f3b6097e7a6bd7649deb30715323072a159c0e6b71b689bd245c146cc0';
-        expect(getFormattedAddress(address, 'starknet')).toEqual(
-          '0x02a0a8f3b6097e7a6bd7649deb30715323072a159c0e6b71b689bd245c146cc0'
-        );
-      });
+        test('should return checksummed EVM address when given lowercase input', () => {
+          const address = '0x91fd2c8d24767db4ece7069aa27832ffaf8590f3';
+          expect(getFormattedAddress(address, 'evm')).toEqual(
+            '0x91FD2c8d24767db4Ece7069AA27832ffaf8590f3'
+          );
+        });
 
-      test('returns an EVM address as starknet address', () => {
-        const address = '0x91FD2c8d24767db4Ece7069AA27832ffaf8590f3';
-        expect(getFormattedAddress(address, 'starknet')).toEqual(
-          '0x00000000000000000000000091fd2c8d24767db4ece7069aa27832ffaf8590f3'
-        );
-      });
+        test('should return checksummed EVM address when given uppercase input', () => {
+          const uppercaseAddress = '0x91FD2C8D24767DB4ECE7069AA27832FFAF8590F3';
+          expect(getFormattedAddress(uppercaseAddress, 'evm')).toEqual(
+            '0x91FD2c8d24767db4Ece7069AA27832ffaf8590f3'
+          );
+        });
+
+        test('should throw error when forcing EVM parsing on address with uppercase 0X prefix', () => {
+          const uppercaseHexPrefix =
+            '0X91FD2C8D24767DB4ECE7069AA27832FFAF8590F3';
+          expect(() => getFormattedAddress(uppercaseHexPrefix, 'evm')).toThrow(
+            'Invalid evm address: 0X91FD2C8D24767DB4ECE7069AA27832FFAF8590F3'
+          );
+        });
+
+        test('should throw error when forcing EVM parsing on invalid mixed case address', () => {
+          const invalidMixedCaseAddress =
+            '0x91Fd2C8d24767Db4eCe7069aA27832FfaF8590F3';
+          expect(() =>
+            getFormattedAddress(invalidMixedCaseAddress, 'evm')
+          ).toThrow(
+            'Invalid evm address: 0x91Fd2C8d24767Db4eCe7069aA27832FfaF8590F3'
+          );
+        });
 
-      test('throws an error when the address is not a starknet address', () => {
-        const address = 'hello';
-        expect(() => getFormattedAddress(address, 'starknet')).toThrow();
+        test('should throw error when address is not an EVM address', () => {
+          const address =
+            '0x2a0a8f3b6097e7a6bd7649deb30715323072a159c0e6b71b689bd245c146cc0';
+          expect(() => getFormattedAddress(address, 'evm')).toThrow(
+            'Invalid evm address: 0x2a0a8f3b6097e7a6bd7649deb30715323072a159c0e6b71b689bd245c146cc0'
+          );
+        });
       });
 
-      test('throws an error when the address is not an EVM address', () => {
-        const address =
-          '0x2a0a8f3b6097e7a6bd7649deb30715323072a159c0e6b71b689bd245c146cc0';
-        expect(() => getFormattedAddress(address, 'evm')).toThrow();
+      describe('Starknet type parsing', () => {
+        test('should return padded and lowercased starknet address when given unpadded input', () => {
+          const address =
+            '0x2a0a8f3b6097e7a6bd7649deb30715323072a159c0e6b71b689bd245c146cc0';
+          expect(getFormattedAddress(address, 'starknet')).toEqual(
+            '0x02a0a8f3b6097e7a6bd7649deb30715323072a159c0e6b71b689bd245c146cc0'
+          );
+        });
+
+        test('should return padded and lowercased starknet address when given lowercase input', () => {
+          const address =
+            '0x02a0a8f3b6097e7a6bd7649deb30715323072a159c0e6b71b689bd245c146cc0';
+          expect(getFormattedAddress(address, 'starknet')).toEqual(
+            '0x02a0a8f3b6097e7a6bd7649deb30715323072a159c0e6b71b689bd245c146cc0'
+          );
+        });
+
+        test('should return padded and lowercased starknet address when given uppercase Starknet input', () => {
+          const uppercaseAddress =
+            '0x02A0A8F3B6097E7A6BD7649DEB30715323072A159C0E6B71B689BD245C146CC0';
+          expect(getFormattedAddress(uppercaseAddress, 'starknet')).toEqual(
+            '0x02a0a8f3b6097e7a6bd7649deb30715323072a159c0e6b71b689bd245c146cc0'
+          );
+        });
+
+        test('should return padded and lowercased starknet address when given checksum Starknet input', () => {
+          const checksumAddress =
+            '0x02a0a8F3B6097e7A6bd7649DEB30715323072A159c0E6B71B689Bd245c146cC0';
+          expect(getFormattedAddress(checksumAddress, 'starknet')).toEqual(
+            '0x02a0a8f3b6097e7a6bd7649deb30715323072a159c0e6b71b689bd245c146cc0'
+          );
+        });
+
+        test('should return padded and lowercased starknet address when given mixed case Starknet input', () => {
+          const mixedCaseAddress =
+            '0x02A0a8F3B6097e7A6bD7649DEB30715323072a159C0e6b71B689BD245c146Cc0';
+          expect(getFormattedAddress(mixedCaseAddress, 'starknet')).toEqual(
+            '0x02a0a8f3b6097e7a6bd7649deb30715323072a159c0e6b71b689bd245c146cc0'
+          );
+        });
+
+        test('should return EVM address as starknet address when explicitly formatted', () => {
+          const address = '0x91FD2c8d24767db4Ece7069AA27832ffaf8590f3';
+          expect(getFormattedAddress(address, 'starknet')).toEqual(
+            '0x00000000000000000000000091fd2c8d24767db4ece7069aa27832ffaf8590f3'
+          );
+        });
+
+        test('should throw error when given invalid Starknet address with explicit format', () => {
+          const invalidStarknetAddress = '0xinvalidstarknetaddresshere';
+          expect(() =>
+            getFormattedAddress(invalidStarknetAddress, 'starknet')
+          ).toThrow('Invalid starknet address: 0xinvalidstarknetaddresshere');
+        });
       });
     });
 
     describe('when not passing an address type', () => {
-      test('returns a checksummed EVM address for an EVM input', () => {
-        const address = '0x91fd2c8d24767db4ece7069aa27832ffaf8590f3';
-        expect(getFormattedAddress(address)).toEqual(
-          '0x91FD2c8d24767db4Ece7069AA27832ffaf8590f3'
-        );
-      });
+      describe('EVM address auto-detection', () => {
+        test('should auto-detect and format valid 42-char lowercase EVM address', () => {
+          const address = '0x91fd2c8d24767db4ece7069aa27832ffaf8590f3';
+          expect(getFormattedAddress(address)).toEqual(
+            '0x91FD2c8d24767db4Ece7069AA27832ffaf8590f3'
+          );
+        });
 
-      test('returns a padded and lowercased starknet address for a Starknet input', () => {
-        const address =
-          '0x2a0a8f3b6097e7a6bd7649deb30715323072a159c0e6b71b689bd245c146cc0';
-        expect(getFormattedAddress(address)).toEqual(
-          '0x02a0a8f3b6097e7a6bd7649deb30715323072a159c0e6b71b689bd245c146cc0'
-        );
+        test('should auto-detect and format valid 42-char uppercase EVM address', () => {
+          const address = '0x91FD2C8D24767DB4ECE7069AA27832FFAF8590F3';
+          expect(getFormattedAddress(address)).toEqual(
+            '0x91FD2c8d24767db4Ece7069AA27832ffaf8590f3'
+          );
+        });
+
+        test('should auto-detect and format valid 42-char checksummed EVM address', () => {
+          const address = '0x91FD2c8d24767db4Ece7069AA27832ffaf8590f3';
+          expect(getFormattedAddress(address)).toEqual(
+            '0x91FD2c8d24767db4Ece7069AA27832ffaf8590f3'
+          );
+        });
+
+        test('should throw error when auto-detecting invalid mixed case EVM address', () => {
+          const invalidMixedCaseAddress =
+            '0x91Fd2C8d24767Db4eCe7069aA27832FfaF8590F3';
+          expect(() => getFormattedAddress(invalidMixedCaseAddress)).toThrow(
+            'Invalid evm address: 0x91Fd2C8d24767Db4eCe7069aA27832FfaF8590F3'
+          );
+        });
+
+        test('should throw error when auto-detecting 42-char invalid hex address', () => {
+          const invalidHexAddress =
+            '0xgggggggggggggggggggggggggggggggggggggggg';
+          expect(() => getFormattedAddress(invalidHexAddress)).toThrow(
+            'Invalid evm address: 0xgggggggggggggggggggggggggggggggggggggggg'
+          );
+        });
+
+        test('should throw error when auto-detecting EVM address with uppercase 0X prefix', () => {
+          const uppercaseHexPrefix =
+            '0X91FD2C8D24767DB4ECE7069AA27832FFAF8590F3';
+          expect(() => getFormattedAddress(uppercaseHexPrefix)).toThrow(
+            'Invalid evm address: 0X91FD2C8D24767DB4ECE7069AA27832FFAF8590F3'
+          );
+        });
       });
 
-      test('throws an error when the input is not address-like', () => {
-        const address = 'hello';
-        expect(() => getFormattedAddress(address)).toThrow();
+      describe('Starknet address auto-detection', () => {
+        test('should auto-detect and format valid unpadded Starknet address', () => {
+          const address =
+            '0x2a0a8f3b6097e7a6bd7649deb30715323072a159c0e6b71b689bd245c146cc0';
+          expect(getFormattedAddress(address)).toEqual(
+            '0x02a0a8f3b6097e7a6bd7649deb30715323072a159c0e6b71b689bd245c146cc0'
+          );
+        });
+
+        test('should auto-detect and format valid padded Starknet address', () => {
+          const address =
+            '0x02a0a8f3b6097e7a6bd7649deb30715323072a159c0e6b71b689bd245c146cc0';
+          expect(getFormattedAddress(address)).toEqual(
+            '0x02a0a8f3b6097e7a6bd7649deb30715323072a159c0e6b71b689bd245c146cc0'
+          );
+        });
+
+        test('should auto-detect and format uppercase Starknet address', () => {
+          const address =
+            '0x02A0A8F3B6097E7A6BD7649DEB30715323072A159C0E6B71B689BD245C146CC0';
+          expect(getFormattedAddress(address)).toEqual(
+            '0x02a0a8f3b6097e7a6bd7649deb30715323072a159c0e6b71b689bd245c146cc0'
+          );
+        });
+
+        test('should return padded and lowercased address when input has uppercase 0X prefix', () => {
+          const fullyUppercaseAddress =
+            '0X02A0A8F3B6097E7A6BD7649DEB30715323072A159C0E6B71B689BD245C146CC0';
+          expect(getFormattedAddress(fullyUppercaseAddress)).toEqual(
+            '0x02a0a8f3b6097e7a6bd7649deb30715323072a159c0e6b71b689bd245c146cc0'
+          );
+        });
+
+        test('should return padded and lowercased address when given short input', () => {
+          const address = '0x1';
+          expect(getFormattedAddress(address)).toEqual(
+            '0x0000000000000000000000000000000000000000000000000000000000000001'
+          );
+        });
+
+        test('should auto-detect actual 41-char address as Starknet', () => {
+          const address = '0x123456789012345678901234567890123456789';
+          expect(getFormattedAddress(address)).toEqual(
+            '0x0000000000000000000000000123456789012345678901234567890123456789'
+          );
+        });
+
+        test('should auto-detect 43+ char address as Starknet', () => {
+          const address = '0x123456789012345678901234567890123456789012';
+          expect(getFormattedAddress(address)).toEqual(
+            '0x0000000000000000000000123456789012345678901234567890123456789012'
+          );
+        });
       });
 
-      test('returns a padded and lowercased starknet address for any non-EVM like address input', () => {
-        const address = '0x1';
-        expect(getFormattedAddress(address)).toEqual(
-          '0x0000000000000000000000000000000000000000000000000000000000000001'
-        );
+      describe('Invalid address format', () => {
+        test('should throw error when passing invalid format argument', () => {
+          const validAddress = '0x91fd2c8d24767db4ece7069aa27832ffaf8590f3';
+          expect(() => getFormattedAddress(validAddress, 'invalid')).toThrow(
+            'Invalid invalid address: 0x91fd2c8d24767db4ece7069aa27832ffaf8590f3'
+          );
+        });
+
+        test('should treat undefined format parameter as auto-detection', () => {
+          const evmAddress = '0x91fd2c8d24767db4ece7069aa27832ffaf8590f3';
+          expect(getFormattedAddress(evmAddress, undefined)).toEqual(
+            '0x91FD2c8d24767db4Ece7069AA27832ffaf8590f3'
+          );
+        });
+
+        test('should throw error when parsing invalid string', () => {
+          const invalidString = 'hello';
+          expect(() => getFormattedAddress(invalidString)).toThrow(
+            'Invalid address: hello'
+          );
+        });
+
+        test('should throw error when parsing empty string', () => {
+          const emptyString = '';
+          expect(() => getFormattedAddress(emptyString)).toThrow(
+            'Invalid address: '
+          );
+        });
+
+        test('should throw error when parsing null input', () => {
+          expect(() => getFormattedAddress(null)).toThrow(
+            'Invalid address: null'
+          );
+        });
+
+        test('should throw error when parsing undefined input', () => {
+          expect(() => getFormattedAddress(undefined)).toThrow(
+            'Invalid address: undefined'
+          );
+        });
+
+        test('should throw error when parsing number input', () => {
+          expect(() => getFormattedAddress(123)).toThrow(
+            'Invalid address: 123'
+          );
+        });
+
+        test('should throw error when parsing object input', () => {
+          expect(() => getFormattedAddress({})).toThrow(
+            'Invalid address: [object Object]'
+          );
+        });
       });
     });
   });

package/src/utils.ts

@@ -1,5 +1,4 @@
 import fetch from 'cross-fetch';
-import { Interface } from '@ethersproject/abi';
 import { Contract } from '@ethersproject/contracts';
 import { getAddress, isAddress } from '@ethersproject/address';
 import { parseUnits } from '@ethersproject/units';
@@ -8,7 +7,6 @@ import { jsonToGraphQLQuery } from 'json-to-graphql-query';
 import Ajv from 'ajv';
 import addFormats from 'ajv-formats';
 import addErrors from 'ajv-errors';
-import Multicaller from './utils/multicaller';
 import { getSnapshots } from './utils/blockfinder';
 import getProvider from './utils/provider';
 import { signMessage, getBlockNumber } from './utils/web3';
@@ -18,6 +16,7 @@ import networks from './networks.json';
 import voting from './voting';
 import getDelegatesBySpace, { SNAPSHOT_SUBGRAPH_URL } from './utils/delegation';
 import { validateAndParseAddress } from 'starknet';
+import { multicall, Multicaller } from './multicall';
 
 interface Options {
   url?: string;
@@ -45,16 +44,6 @@ const ENS_ABI = [
   'function resolver(bytes32 node) view returns (address)' // ENS registry ABI
 ];
 const EMPTY_ADDRESS = '0x0000000000000000000000000000000000000000';
-const STARKNET_NETWORKS = {
-  '0x534e5f4d41494e': {
-    name: 'Starknet',
-    testnet: false
-  },
-  '0x534e5f5345504f4c4941': {
-    name: 'Starknet Sepolia',
-    testnet: true
-  }
-};
 
 const scoreApiHeaders = {
   Accept: 'application/json',
@@ -189,24 +178,6 @@ ajv.addKeyword({
   }
 });
 
-ajv.addKeyword({
-  keyword: 'starknetNetwork',
-  validate: function (schema, data) {
-    // @ts-ignore
-    const snapshotEnv = this.snapshotEnv || 'default';
-    if (snapshotEnv === 'mainnet') {
-      return Object.keys(STARKNET_NETWORKS)
-        .filter((id) => !STARKNET_NETWORKS[id].testnet)
-        .includes(data);
-    }
-
-    return Object.keys(STARKNET_NETWORKS).includes(data);
-  },
-  error: {
-    message: 'network not allowed'
-  }
-});
-
 // Custom URL format to allow empty string values
 // https://github.com/snapshot-labs/snapshot.js/pull/541/files
 ajv.addFormat('customUrl', {
@@ -280,48 +251,6 @@ export async function call(provider, abi: any[], call: any[], options?) {
     return Promise.reject(e);
   }
 }
-
-export async function multicall(
-  network: string,
-  provider,
-  abi: any[],
-  calls: any[],
-  options?
-) {
-  const multicallAbi = [
-    'function aggregate(tuple(address target, bytes callData)[] calls) view returns (uint256 blockNumber, bytes[] returnData)'
-  ];
-  const multicallAddress =
-    options?.multicallAddress || networks[network].multicall;
-  const multi = new Contract(multicallAddress, multicallAbi, provider);
-  const itf = new Interface(abi);
-  try {
-    const max = options?.limit || 500;
-    if (options?.limit) delete options.limit;
-    const pages = Math.ceil(calls.length / max);
-    const promises: any = [];
-    Array.from(Array(pages)).forEach((x, i) => {
-      const callsInPage = calls.slice(max * i, max * (i + 1));
-      promises.push(
-        multi.aggregate(
-          callsInPage.map((call) => [
-            call[0].toLowerCase(),
-            itf.encodeFunctionData(call[1], call[2])
-          ]),
-          options || {}
-        )
-      );
-    });
-    let results: any = await Promise.all(promises);
-    results = results.reduce((prev: any, [, res]: any) => prev.concat(res), []);
-    return results.map((call, i) =>
-      itf.decodeFunctionResult(calls[i][1], call)
-    );
-  } catch (e: any) {
-    return Promise.reject(e);
-  }
-}
-
 export async function subgraphRequest(url: string, query, options: any = {}) {
   const body: Record<string, any> = { query: jsonToGraphQLQuery({ query }) };
   if (options.variables) body.variables = options.variables;
@@ -634,13 +563,13 @@ export async function getEnsTextRecord(
     ]) // Query for text record from each resolver
   ];
 
-  const [[resolverAddress], ...textRecords]: string[][] = await multicall(
+  const [[resolverAddress], ...textRecords] = (await multicall(
     network,
     provider,
     ENS_ABI,
     calls,
     multicallOptions
-  );
+  )) as string[][];
 
   const resolverIndex = ensResolvers.indexOf(resolverAddress);
   return resolverIndex !== -1 ? textRecords[resolverIndex]?.[0] : null;
@@ -830,16 +759,18 @@ export function getFormattedAddress(
   address: string,
   format?: 'evm' | 'starknet'
 ): string {
-  // Consider non-evm addresses as Starknet by default
-  // as there's no other way to differentiate them
-  const addressType = format ?? (isEvmAddress(address) ? 'evm' : 'starknet');
+  if (typeof address !== 'string' || !/^0[xX]/.test(address)) {
+    throw new Error(`Invalid address: ${address}`);
+  }
+
+  const addressType = format ?? (address.length === 42 ? 'evm' : 'starknet');
 
   if (addressType === 'evm' && isEvmAddress(address))
     return getAddress(address);
   if (addressType === 'starknet' && isStarknetAddress(address))
     return validateAndParseAddress(address);
 
-  throw new Error(`Invalid address: ${address}`);
+  throw new Error(`Invalid ${addressType} address: ${address}`);
 }
 
 function inputError(message: string) {

package/dist/src/utils/multicaller.d.ts

@@ -1,12 +0,0 @@
-import { StaticJsonRpcProvider } from '@ethersproject/providers';
-export default class Multicaller {
-    network: string;
-    provider: StaticJsonRpcProvider;
-    abi: any[];
-    options: any;
-    calls: any[];
-    paths: any[];
-    constructor(network: string, provider: StaticJsonRpcProvider, abi: any[], options?: any);
-    call(path: any, address: any, fn: any, params?: any): Multicaller;
-    execute(from?: any): Promise<any>;
-}