thirdweb 0.2.8 → 0.3.1

package/src/common/error.ts

@@ -1,49 +1,3 @@
-/**
- * Error that may get thrown if IPFS returns nothing for a given uri.
- * @internal
- */
-export class NotFoundError extends Error {
-  /** @internal */
-  constructor(identifier?: string) {
-    super(identifier ? `Object with id ${identifier} NOT FOUND` : "NOT_FOUND");
-  }
-}
-
-/**
- * Error that may get thrown if an invalid address was passed
- * @internal
- */
-export class InvalidAddressError extends Error {
-  /** @internal */
-  constructor(address?: string) {
-    super(
-      address ? `'${address}' is an invalid address` : "Invalid address passed"
-    );
-  }
-}
-
-/**
- * @internal
- */
-export class MissingRoleError extends Error {
-  /** @internal */
-  /** @internal */
-  constructor(address: string, role: string) {
-    super(`MISSING ROLE: ${address} does not have the '${role}' role`);
-  }
-}
-
-/**
- * @internal
- */
-export class AssetNotFoundError extends Error {
-  /** @internal */
-  /** @internal */
-  constructor(message = "The asset you're trying to use could not be found.") {
-    super(`message: ${message}`);
-  }
-}
-
 /**
  * @internal
  */
@@ -54,16 +8,6 @@ export class UploadError extends Error {
   }
 }
 
-/**
- * @internal
- */
-export class FileNameMissingError extends Error {
-  /** @internal */
-  constructor() {
-    super("File name is required when object is not a `File` type object.");
-  }
-}
-
 /**
  * @internal
  */
@@ -71,43 +15,11 @@ export class DuplicateFileNameError extends Error {
   /** @internal */
   constructor(fileName: string) {
     super(
-      `DUPLICATE_FILE_NAME_ERROR: File name ${fileName} was passed for more than one file.`
+      `DUPLICATE_FILE_NAME_ERROR: File name ${fileName} was passed for more than one file.`,
     );
   }
 }
 
-/**
- * @internal
- */
-export class NotEnoughTokensError extends Error {
-  /** @internal */
-  constructor(contractAddress: string, quantity: number, available: number) {
-    super(
-      `BALANCE ERROR: you do not have enough balance on contract ${contractAddress} to use ${quantity} tokens. You have ${available} tokens available.`
-    );
-  }
-}
-
-/**
- * @internal
- */
-export class MissingOwnerRoleError extends Error {
-  /** @internal */
-  constructor() {
-    super(`LIST ERROR: you should be the owner of the token to list it.`);
-  }
-}
-
-/**
- * @internal
- */
-export class QuantityAboveLimitError extends Error {
-  /** @internal */
-  constructor(quantity: string) {
-    super(`BUY ERROR: You cannot buy more than ${quantity} tokens`);
-  }
-}
-
 /**
  * Thrown when data fails to fetch from storage.
  * @internal
@@ -121,105 +33,3 @@ export class FetchError extends Error {
     this.innerError = innerError;
   }
 }
-
-/**
- * Thrown when attempting to create a snapshot with duplicate leafs
- * @internal
- */
-export class DuplicateLeafsError extends Error {
-  constructor(message?: string) {
-    super(`DUPLICATE_LEAFS${message ? ` : ${message}` : ""}`);
-  }
-}
-
-/**
- * Thrown when attempting to update/cancel an auction that already started
- * @internal
- */
-export class AuctionAlreadyStartedError extends Error {
-  constructor(id?: string) {
-    super(
-      `Auction already started with existing bid${id ? `, id: ${id}` : ""}`
-    );
-  }
-}
-
-/**
- * @internal
- */
-export class FunctionDeprecatedError extends Error {
-  /** @internal */
-  constructor(message: string) {
-    super(`FUNCTION DEPRECATED. ${message ? `Use ${message} instead` : ""}`);
-  }
-}
-/**
- * Thrown when trying to retrieve a listing from a marketplace that doesn't exist
- * @internal
- */
-export class ListingNotFoundError extends Error {
-  constructor(marketplaceContractAddress: string, listingId?: string) {
-    super(
-      `Could not find listing.${
-        marketplaceContractAddress
-          ? ` marketplace address: ${marketplaceContractAddress}`
-          : ""
-      }${listingId ? ` listing id: ${listingId}` : ""}`
-    );
-  }
-}
-
-/**
- * Thrown when trying to retrieve a listing of the wrong type
- * @internal
- */
-export class WrongListingTypeError extends Error {
-  constructor(
-    marketplaceContractAddress: string,
-    listingId?: string,
-    actualType?: string,
-    expectedType?: string
-  ) {
-    super(
-      `Incorrect listing type. Are you sure you're using the right method?.${
-        marketplaceContractAddress
-          ? ` marketplace address: ${marketplaceContractAddress}`
-          : ""
-      }${listingId ? ` listing id: ${listingId}` : ""}${
-        expectedType ? ` expected type: ${expectedType}` : ""
-      }${actualType ? ` actual type: ${actualType}` : ""}`
-    );
-  }
-}
-
-/**
- * Thrown when attempting to transfer an asset that has restricted transferability
- * @internal
- */
-export class RestrictedTransferError extends Error {
-  constructor(assetAddress?: string) {
-    super(
-      `Failed to transfer asset, transfer is restricted.${
-        assetAddress ? ` Address : ${assetAddress}` : ""
-      }`
-    );
-  }
-}
-
-/**
- * Thrown when attempting to execute an admin-role function.
- * @internal
- */
-export class AdminRoleMissingError extends Error {
-  constructor(
-    address?: string,
-    contractAddress?: string,
-    message = "Failed to execute transaction"
-  ) {
-    super(
-      `${message}, admin role is missing${
-        address ? ` on address: ${address}` : ""
-      }${contractAddress ? ` on contract: ${contractAddress}` : ""}`
-    );
-  }
-}

package/src/core/builder/brownie.ts

@@ -0,0 +1,66 @@
+import { logger } from "../helpers/logger";
+import { CompileOptions } from "../interfaces/Builder";
+import { ContractPayload } from "../interfaces/ContractPayload";
+import { BaseBuilder } from "./builder-base";
+import { execSync } from "child_process";
+import { existsSync, readFileSync, rmdirSync } from "fs";
+import { basename, join } from "path";
+import { parse } from "yaml";
+
+export class BrownieBuilder extends BaseBuilder {
+  public async compile(options: CompileOptions): Promise<{
+    contracts: ContractPayload[];
+  }> {
+    const config = parse(
+      readFileSync(join(options.projectPath, "brownie-config.yaml"), "utf-8"),
+    );
+
+    const buildPath = join(
+      options.projectPath,
+      config?.project_structure?.build || "./build",
+    );
+
+    if (options.clean) {
+      logger.info("Cleaning build directory");
+      existsSync(buildPath) && rmdirSync(buildPath, { recursive: true });
+    }
+
+    logger.info("Compiling...");
+    execSync("brownie compile");
+
+    const contractsPath = join(buildPath, "contracts/");
+
+    const contracts: ContractPayload[] = [];
+    const files: string[] = [];
+    this.findFiles(contractsPath, /^.*(?<!dbg)\.json$/, files);
+
+    for (const file of files) {
+      logger.debug("Processing:", file.replace(contractsPath, ""));
+      const contractName = basename(file, ".json");
+      const contractJsonFile = readFileSync(file, "utf-8");
+
+      const contractInfo = JSON.parse(contractJsonFile);
+      const abi = contractInfo.abi;
+      const bytecode = contractInfo.bytecode;
+
+      for (const input of abi) {
+        if (this.isThirdwebContract(input)) {
+          if (contracts.find((c) => c.name === contractName)) {
+            logger.error(
+              `Found multiple contracts with name "${contractName}". Contract names should be unique.`,
+            );
+            process.exit(1);
+          }
+          contracts.push({
+            abi,
+            bytecode,
+            name: contractName,
+          });
+          break;
+        }
+      }
+    }
+
+    return { contracts };
+  }
+}

package/src/core/builder/build.ts

@@ -1,12 +1,14 @@
 import { ContractPayload } from "../interfaces/ContractPayload";
 import { ProjectType } from "./../types/ProjectType";
+import { BrownieBuilder } from "./brownie";
 import { FoundryBuilder } from "./foundry";
 import { HardhatBuilder } from "./hardhat";
+import { TruffleBuilder } from "./truffle";
 
 export default async function build(
   path: string,
   projectType: ProjectType,
-  clean: boolean
+  clean: boolean,
 ): Promise<{
   contracts: ContractPayload[];
 }> {
@@ -29,6 +31,24 @@ export default async function build(
       });
     }
 
+    case "truffle": {
+      const builder = new TruffleBuilder();
+      return await builder.compile({
+        name: "",
+        projectPath: path,
+        clean,
+      });
+    }
+
+    case "brownie": {
+      const builder = new BrownieBuilder();
+      return await builder.compile({
+        name: "",
+        projectPath: path,
+        clean,
+      });
+    }
+
     default: {
       throw new Error("Unknown project type");
     }

package/src/core/builder/builder-base.ts

@@ -1,11 +1,12 @@
-import { existsSync, readdirSync, statSync } from "fs";
-import { basename, join } from "path";
+import { logger } from "../helpers/logger";
 import { CompileOptions, IBuilder } from "../interfaces/Builder";
 import { ContractPayload } from "../interfaces/ContractPayload";
+import { existsSync, readdirSync, statSync } from "fs";
+import { basename, join } from "path";
 
 export abstract class BaseBuilder implements IBuilder {
   abstract compile(
-    options: CompileOptions
+    options: CompileOptions,
   ): Promise<{ contracts: ContractPayload[] }>;
 
   protected isThirdwebContract(input: any): boolean {
@@ -25,14 +26,20 @@ export abstract class BaseBuilder implements IBuilder {
       return;
     }
 
-    var files = readdirSync(startPath);
-    for (var i = 0; i < files.length; i++) {
-      var filename = join(startPath, files[i]);
+    const files = readdirSync(startPath);
+    for (let i = 0; i < files.length; i++) {
+      const filename = join(startPath, files[i]);
       //skip the actual thirdweb contract itself
       if (basename(filename, ".json") === "ThirdwebContract") {
         continue;
       }
-      var stat = statSync(filename);
+      const stat = statSync(filename);
+
+      // brownie has a "depdendencies" directory *inside* the build directory, if we detect that we should skip it
+      if (stat.isDirectory() && basename(filename) === "dependencies") {
+        logger.debug('skipping "dependencies" directory');
+        continue;
+      }
       if (stat.isDirectory()) {
         this.findFiles(filename, filter, results);
       } else if (filter.test(filename)) {

package/src/core/builder/foundry.ts

@@ -1,11 +1,10 @@
-import { execSync } from "child_process";
-import { readFileSync } from "fs";
-import { basename, join } from "path";
 import { logger } from "../helpers/logger";
 import { CompileOptions } from "../interfaces/Builder";
 import { ContractPayload } from "../interfaces/ContractPayload";
-
 import { BaseBuilder } from "./builder-base";
+import { execSync } from "child_process";
+import { readFileSync } from "fs";
+import { basename, join } from "path";
 
 export class FoundryBuilder extends BaseBuilder {
   public async compile(options: CompileOptions): Promise<{
@@ -44,7 +43,7 @@ export class FoundryBuilder extends BaseBuilder {
         if (this.isThirdwebContract(input)) {
           if (contracts.find((c) => c.name === contractName)) {
             logger.error(
-              `Found multiple contracts with name "${contractName}". Contract names should be unique.`
+              `Found multiple contracts with name "${contractName}". Contract names should be unique.`,
             );
             process.exit(1);
           }
@@ -58,11 +57,6 @@ export class FoundryBuilder extends BaseBuilder {
       }
     }
 
-    logger.info(
-      "Detected thirdweb contracts:",
-      contracts.map((c) => c.name).join(", ")
-    );
-
     return { contracts };
   }
 }

package/src/core/builder/hardhat.ts

@@ -1,11 +1,11 @@
-import { existsSync, readdirSync, readFileSync, statSync } from "fs";
-import { HardhatConfig } from "hardhat/types";
-import { basename, join, resolve } from "path";
 import { logger } from "../helpers/logger";
 import { CompileOptions } from "../interfaces/Builder";
 import { ContractPayload } from "../interfaces/ContractPayload";
-import { execSync } from "child_process";
 import { BaseBuilder } from "./builder-base";
+import { execSync } from "child_process";
+import { existsSync, readFileSync, readdirSync, statSync } from "fs";
+import { HardhatConfig } from "hardhat/types";
+import { basename, join, resolve } from "path";
 
 export class HardhatBuilder extends BaseBuilder {
   public async compile(options: CompileOptions): Promise<{
@@ -23,25 +23,25 @@ export class HardhatBuilder extends BaseBuilder {
     // then we look up the hardhat config extractor file path from there
     const configExtractorScriptPath = resolve(
       __dirname,
-      "../helpers/hardhat-config-extractor.js"
+      "../helpers/hardhat-config-extractor.js",
     );
 
     //the hardhat extractor **logs out** the runtime config of hardhat, we take that stdout and parse it
     const stringifiedConfig = execSync(
-      `npx hardhat run ${configExtractorScriptPath} --no-compile`
+      `npx hardhat run ${configExtractorScriptPath} --no-compile`,
     ).toString();
     //voila the hardhat config
     const actualHardhatConfig = JSON.parse(stringifiedConfig) as HardhatConfig;
 
     logger.debug(
       "successfully extracted hardhat config",
-      actualHardhatConfig.paths
+      actualHardhatConfig.paths,
     );
 
     const artifactsPath = actualHardhatConfig.paths.artifacts;
     const sourcesDir = actualHardhatConfig.paths.sources.replace(
       options.projectPath,
-      ""
+      "",
     );
     const contractsPath = join(artifactsPath, sourcesDir);
 
@@ -62,7 +62,7 @@ export class HardhatBuilder extends BaseBuilder {
         if (this.isThirdwebContract(input)) {
           if (contracts.find((c) => c.name === contractName)) {
             logger.error(
-              `Found multiple contracts with name "${contractName}". Contract names should be unique.`
+              `Found multiple contracts with name "${contractName}". Contract names should be unique.`,
             );
             process.exit(1);
           }
@@ -76,11 +76,6 @@ export class HardhatBuilder extends BaseBuilder {
       }
     }
 
-    logger.info(
-      "Detected thirdweb contracts:",
-      contracts.map((c) => c.name).join(", ")
-    );
-
     return {
       contracts,
     };

package/src/core/builder/truffle.ts

@@ -0,0 +1,65 @@
+import { logger } from "../helpers/logger";
+import { CompileOptions } from "../interfaces/Builder";
+import { ContractPayload } from "../interfaces/ContractPayload";
+import { BaseBuilder } from "./builder-base";
+import { execSync } from "child_process";
+import { existsSync, readFileSync, rmdirSync } from "fs";
+import { basename, join } from "path";
+
+export class TruffleBuilder extends BaseBuilder {
+  public async compile(options: CompileOptions): Promise<{
+    contracts: ContractPayload[];
+  }> {
+    // get the current config first
+    const truffleConfig = require(join(
+      options.projectPath,
+      "truffle-config.js",
+    ));
+
+    const buildPath = join(
+      options.projectPath,
+      truffleConfig.contracts_build_directory || "./build/contracts",
+    );
+
+    if (options.clean) {
+      logger.info("Cleaning build directory");
+      existsSync(buildPath) && rmdirSync(buildPath, { recursive: true });
+    }
+
+    logger.info("Compiling...");
+    execSync("npx truffle compile");
+
+    const contracts: ContractPayload[] = [];
+    const files: string[] = [];
+    this.findFiles(buildPath, /^.*(?<!dbg)\.json$/, files);
+
+    for (const file of files) {
+      logger.debug("Processing:", file.replace(buildPath, ""));
+      const contractName = basename(file, ".json");
+      const contractJsonFile = readFileSync(file, "utf-8");
+
+      const contractInfo = JSON.parse(contractJsonFile);
+      const abi = contractInfo.abi;
+      const bytecode = contractInfo.bytecode;
+
+      for (const input of abi) {
+        if (this.isThirdwebContract(input)) {
+          if (contracts.find((c) => c.name === contractName)) {
+            logger.error(
+              `Found multiple contracts with name "${contractName}". Contract names should be unique.`,
+            );
+            process.exit(1);
+          }
+          contracts.push({
+            abi,
+            bytecode,
+            name: contractName,
+          });
+          break;
+        }
+      }
+    }
+
+    return { contracts };
+  }
+}

package/src/core/detection/brownie.ts

@@ -0,0 +1,13 @@
+import { logger } from "../helpers/logger";
+import { ProjectType } from "../types/ProjectType";
+import { Detector } from "./detector";
+import { existsSync } from "fs";
+
+export default class BrownieDetector implements Detector {
+  public projectType: ProjectType = "brownie";
+
+  public matches(path: string): boolean {
+    logger.debug("Checking if " + path + " is a Foundry project");
+    return existsSync(path + "/brownie-config.yaml");
+  }
+}

package/src/core/detection/detect.ts

@@ -1,16 +1,46 @@
+import { logger } from "../helpers/logger";
 import { ProjectType } from "../types/ProjectType";
+import BrownieDetector from "./brownie";
 import { Detector } from "./detector";
 import FoundryDetector from "./foundry";
 import HardhatDetector from "./hardhat";
+import TruffleDetector from "./truffle";
+import inquirer from "inquirer";
 
 export default async function detect(path: string): Promise<ProjectType> {
-  const detectors: Detector[] = [new HardhatDetector(), new FoundryDetector()];
+  const detectors: Detector[] = [
+    new HardhatDetector(),
+    new FoundryDetector(),
+    new TruffleDetector(),
+    new BrownieDetector(),
+  ];
 
-  for (const detector of detectors) {
-    if (await detector.matches(path)) {
-      return detector.projectType;
-    }
+  const possibleProjectTypes = detectors
+    .filter((detector) => detector.matches(path))
+    .map((detector) => detector.projectType);
+
+  //if there is no project returned at all then just return unknown}
+  if (!possibleProjectTypes.length) {
+    return "unknown";
+  }
+  //if there is only one possible option just return it
+  if (possibleProjectTypes.length === 1) {
+    logger.info("Detected project type:", possibleProjectTypes[0]);
+    return possibleProjectTypes[0];
   }
 
-  return "unknown";
+  logger.info(
+    "Detected multiple possible build tools:",
+    possibleProjectTypes.map((s) => `"${s}"`).join(", "),
+  );
+
+  const question = "How would you like to compile your contracts";
+
+  const answer = await inquirer.prompt({
+    type: "list",
+    choices: possibleProjectTypes,
+    name: question,
+  });
+
+  return answer[question];
 }

package/src/core/detection/detector.ts

@@ -3,5 +3,5 @@ import { ProjectType } from "../types/ProjectType";
 export interface Detector {
   projectType: ProjectType;
 
-  matches(path: string): Promise<boolean>;
+  matches(path: string): boolean;
 }

package/src/core/detection/foundry.ts

@@ -1,12 +1,12 @@
-import { existsSync } from "fs";
 import { logger } from "../helpers/logger";
 import { ProjectType } from "../types/ProjectType";
 import { Detector } from "./detector";
+import { existsSync } from "fs";
 
 export default class FoundryDetector implements Detector {
   public projectType: ProjectType = "foundry";
 
-  public async matches(path: string): Promise<boolean> {
+  public matches(path: string): boolean {
     logger.debug("Checking if " + path + " is a Foundry project");
     return existsSync(path + "/foundry.toml");
   }

package/src/core/detection/hardhat.ts

@@ -1,12 +1,12 @@
-import { existsSync } from "fs";
 import { logger } from "../helpers/logger";
 import { ProjectType } from "../types/ProjectType";
 import { Detector } from "./detector";
+import { existsSync } from "fs";
 
 export default class HardhatDetector implements Detector {
   public projectType: ProjectType = "hardhat";
 
-  public async matches(path: string): Promise<boolean> {
+  public matches(path: string): boolean {
     logger.debug("Checking if " + path + " is a Hardhat project");
     return (
       existsSync(path + "/hardhat.config.js") ||

package/src/core/detection/truffle.ts

@@ -0,0 +1,13 @@
+import { logger } from "../helpers/logger";
+import { ProjectType } from "../types/ProjectType";
+import { Detector } from "./detector";
+import { existsSync } from "fs";
+
+export default class TruffleDetector implements Detector {
+  public projectType: ProjectType = "truffle" as const;
+
+  public matches(path: string): boolean {
+    logger.debug("Checking if " + path + " is a Truffle project");
+    return existsSync(path + "/truffle-config.js");
+  }
+}

package/src/core/helpers/storage.ts

@@ -14,7 +14,7 @@ import { Json } from "../types";
  */
 export function replaceFilePropertiesWithHashes(
   object: Record<string, any>,
-  cids: string[]
+  cids: string[],
 ) {
   const keys = Object.keys(object);
   for (const key in keys) {
@@ -43,7 +43,7 @@ export function replaceFilePropertiesWithHashes(
 export function replaceHashWithGatewayUrl(
   object: Record<string, any>,
   scheme: string,
-  gatewayUrl: string
+  gatewayUrl: string,
 ): Record<string, any> {
   const keys = Object.keys(object);
   for (const key in keys) {
@@ -75,7 +75,7 @@ export function replaceHashWithGatewayUrl(
 export function resolveGatewayUrl<T extends Json>(
   ipfsHash: T,
   scheme: string,
-  gatewayUrl: string
+  gatewayUrl: string,
 ): T {
   if (typeof ipfsHash === "string") {
     return ipfsHash && ipfsHash.toLowerCase().includes(scheme)