add hook into cacheing in version range strategy and adjust source fetcher

Author: eggplantzzz

packages/compile-solidity/src/compilerSupplier/index.ts

@@ -6,6 +6,18 @@ import { Docker, Local, Native, VersionRange } from "./loadingStrategies";
 
 const defaultSolcVersion = "0.5.16";
 
+type CompilerSupplierConstructorArgs = {
+  events?: any;
+  solcConfig: {
+    version?: string;
+    docker?: boolean;
+    compilerRoots?: string[];
+    dockerTagsUrl?: string;
+    spawn: any;
+  };
+  cache?: string;
+};
+
 type CompilerSupplierStrategy =
   | Docker
   | Native
@@ -15,10 +27,10 @@ type CompilerSupplierStrategy =
 
 export class CompilerSupplier {
   private version: string;
-  private docker: boolean;
+  private docker?: boolean;
   private strategyOptions: StrategyOptions;
 
-  constructor({ events, solcConfig }) {
+  constructor({ events, solcConfig, cache }: CompilerSupplierConstructorArgs) {
     const { version, docker, compilerRoots, dockerTagsUrl, spawn } = solcConfig;
     this.version = version ? version : defaultSolcVersion;
     this.docker = docker;
@@ -28,6 +40,7 @@ export class CompilerSupplier {
     if (compilerRoots) this.strategyOptions.compilerRoots = compilerRoots;
     if (events) this.strategyOptions.events = events;
     if (spawn) this.strategyOptions.spawn = spawn;
+    if (cache) this.strategyOptions.cache = cache;
   }
 
   async load() {
@@ -36,9 +49,12 @@ export class CompilerSupplier {
     let strategy: CompilerSupplierStrategy;
     const useDocker = this.docker;
     const useNative = userSpecification === "native";
-    const useSpecifiedLocal =
-      userSpecification &&
-      (fs.existsSync(userSpecification) || path.isAbsolute(userSpecification));
+    let useSpecifiedLocal: boolean | string | undefined;
+    if (!userSpecification) {
+      useSpecifiedLocal =
+        userSpecification &&
+        (fs.existsSync(userSpecification) || path.isAbsolute(userSpecification));
+    }
     const isValidVersionRange = semver.validRange(userSpecification);
 
     if (useDocker) {

packages/compile-solidity/src/compilerSupplier/loadingStrategies/VersionRange.ts

@@ -24,7 +24,7 @@ type SolidityCompilersList = {
 
 export class VersionRange {
   public config: StrategyOptions;
-  public cache: Cache;
+  public cache: Cache | null;
 
   constructor(options: StrategyOptions) {
     const defaultConfig = {
@@ -41,19 +41,32 @@ export class VersionRange {
     };
     this.config = Object.assign({}, defaultConfig, options);
 
-    this.cache = new Cache();
+    switch (options.cache) {
+      case "fileSystem":
+        this.cache = new Cache();
+        break;
+      case "noCache":
+        this.cache = null;
+        break;
+      default:
+        this.cache = new Cache();
+    }
   }
 
   async load(versionRange: string) {
     const rangeIsSingleVersion = semver.valid(versionRange);
-    if (rangeIsSingleVersion && this.versionIsCached(versionRange)) {
+    if (
+      rangeIsSingleVersion &&
+      this.cache &&
+      this.versionIsCached(versionRange)
+    ) {
       return this.getCachedSolcByVersionRange(versionRange);
     }
 
     try {
       return await this.getSolcFromCacheOrUrl(versionRange);
     } catch (error) {
-      if (error.message.includes("Failed to complete request")) {
+      if (error.message.includes("Failed to complete request") && this.cache) {
         return this.getSatisfyingVersionFromCache(versionRange);
       }
       throw error;
@@ -117,6 +130,9 @@ export class VersionRange {
   }
 
   getCachedSolcByFileName(fileName: string) {
+    if (!this.cache) {
+      this.throwNoCacheError();
+    }
     const listeners = observeListeners();
     try {
       const filePath = this.cache.resolve(fileName);
@@ -130,6 +146,9 @@ export class VersionRange {
 
   // Range can also be a single version specification like "0.5.0"
   getCachedSolcByVersionRange(version: string) {
+    if (!this.cache) {
+      this.throwNoCacheError();
+    }
     const cachedCompilerFileNames = this.cache.list();
     const validVersions = cachedCompilerFileNames.filter(fileName => {
       const match = fileName.match(/v\d+\.\d+\.\d+.*/);
@@ -144,6 +163,9 @@ export class VersionRange {
   }
 
   getCachedSolcFileName(commit: string) {
+    if (!this.cache) {
+      this.throwNoCacheError();
+    }
     const cachedCompilerFileNames = this.cache.list();
     return cachedCompilerFileNames.find(fileName => {
       return fileName.includes(commit);
@@ -182,7 +204,9 @@ export class VersionRange {
       throw error;
     }
     events.emit("downloadCompiler:succeed");
-    this.cache.add(response.data, fileName);
+    if (this.cache) {
+      this.cache.add(response.data, fileName);
+    }
     return this.compilerFromString(response.data);
   }
 
@@ -219,7 +243,7 @@ export class VersionRange {
       );
       if (!fileName) throw new NoVersionError(versionToUse);
 
-      if (this.cache.has(fileName)) {
+      if (this.cache?.has(fileName)) {
         return this.getCachedSolcByFileName(fileName);
       }
       return await this.getAndCacheSolcByUrl(fileName, index);
@@ -275,6 +299,9 @@ export class VersionRange {
   }
 
   versionIsCached(version: string) {
+    if (!this.cache) {
+      return false;
+    }
     const cachedCompilerFileNames = this.cache.list();
     const cachedVersions = cachedCompilerFileNames
       .map(fileName => {
@@ -286,6 +313,13 @@ export class VersionRange {
       semver.satisfies(cachedVersion, version)
     );
   }
+
+  throwNoCacheError(): never {
+    throw new Error(
+      "You are trying to access the cache but your configuration specifies " +
+        "no cache."
+    );
+  }
 }
 
 export class NoUrlError extends Error {

packages/compile-solidity/src/compilerSupplier/types.ts

@@ -7,4 +7,5 @@ export type StrategyOptions = {
   spawn?: {
     maxBuffer: number;
   };
+  cache?: string;
 };

packages/compile-solidity/src/run.ts

@@ -243,7 +243,8 @@ async function invokeCompiler({ compilerInput, options, solc }): Promise<{
   const supplierOptions = {
     parser: options.parser,
     events: options.events,
-    solcConfig: options.compilers.solc
+    solcConfig: options.compilers.solc,
+    cache: options.compilers.cache
   };
 
   if (!solc) {

packages/fetch-and-compile/lib/fetch.ts

@@ -134,6 +134,12 @@ async function tryFetchAndCompileAddress(
         solc: options
       }
     });
+
+    // @ts-ignore
+    if (window) {
+      externalConfig.compilers.cache = "noCache";
+    }
+
     //if using docker, transform it (this does nothing if not using docker)
     externalConfig = transformIfUsingDocker(
       externalConfig,

packages/source-fetcher/lib/common.ts

@@ -1,6 +1,4 @@
 //these imports aren't actually necessary, but why not :)
-import util from "util";
-import { setTimeout } from "timers";
 import type * as Types from "./types";
 
 export function makeFilename(name: string, extension: string = ".sol"): string {
@@ -14,8 +12,11 @@ export function makeFilename(name: string, extension: string = ".sol"): string {
   }
 }
 
-export const makeTimer: (milliseconds: number) => Promise<void> =
-  util.promisify(setTimeout);
+export const makeTimer = (milliseconds: number): Promise<void> => {
+  return new Promise(resolve => {
+    setTimeout(() => resolve(), milliseconds);
+  });
+};
 
 export function removeLibraries(
   settings: Types.SolcSettings,