@latticexyz/cli 1.40.0 → 1.41.1-alpha.0

package/src/render-solidity/userType.ts

@@ -0,0 +1,132 @@
+import { AbiTypeToSchemaType, getStaticByteLength, SchemaType, SchemaTypeToAbiType } from "@latticexyz/schema-type";
+import { StoreConfig } from "../config/index.js";
+import { ImportDatum, RenderTableType } from "./types.js";
+import { parseStaticArray } from "../config/validation.js";
+
+export type UserTypeInfo = ReturnType<typeof getUserTypeInfo>;
+
+/**
+ * Resolve an abi or user type into a SchemaType
+ */
+export function resolveAbiOrUserType(
+  abiOrUserType: string,
+  config: StoreConfig
+): {
+  schemaType: SchemaType;
+  renderTableType: RenderTableType;
+} {
+  // abi types which directly mirror a SchemaType
+  if (abiOrUserType in AbiTypeToSchemaType) {
+    const schemaType = AbiTypeToSchemaType[abiOrUserType];
+    return {
+      schemaType,
+      renderTableType: getSchemaTypeInfo(schemaType),
+    };
+  }
+  // static arrays
+  const staticArray = parseStaticArray(abiOrUserType);
+  if (staticArray) {
+    if (staticArray.elementType in AbiTypeToSchemaType) {
+      return getStaticArrayTypeInfo(abiOrUserType, staticArray.elementType, staticArray.staticLength);
+    } else {
+      throw new Error("Static arrays of user types are not supported");
+    }
+  }
+  // user types
+  return getUserTypeInfo(abiOrUserType, config);
+}
+
+/**
+ * Get the required import for SchemaType|userType (`undefined` means that no import is required)
+ */
+export function importForAbiOrUserType(
+  abiOrUserType: string,
+  usedInDirectory: string,
+  config: StoreConfig
+): ImportDatum | undefined {
+  // abi types which directly mirror a SchemaType
+  if (abiOrUserType in AbiTypeToSchemaType) {
+    return undefined;
+  }
+  // static arrays
+  const staticArray = parseStaticArray(abiOrUserType);
+  if (staticArray) {
+    return undefined;
+  }
+  // user types
+  return {
+    symbol: abiOrUserType,
+    fromPath: config.userTypesPath + ".sol",
+    usedInPath: usedInDirectory,
+  };
+}
+
+export function getSchemaTypeInfo(schemaType: SchemaType): RenderTableType {
+  const staticByteLength = getStaticByteLength(schemaType);
+  const isDynamic = staticByteLength === 0;
+  const typeId = SchemaTypeToAbiType[schemaType];
+  return {
+    typeId,
+    typeWithLocation: isDynamic ? typeId + " memory" : typeId,
+    enumName: SchemaType[schemaType],
+    staticByteLength,
+    isDynamic,
+    typeWrap: "",
+    typeUnwrap: "",
+    internalTypeId: typeId,
+  };
+}
+
+export function getUserTypeInfo(
+  userType: string,
+  config: StoreConfig
+): {
+  schemaType: SchemaType;
+  renderTableType: RenderTableType;
+} {
+  // enums
+  if (userType in config.enums) {
+    const schemaType = SchemaType.UINT8;
+    const staticByteLength = getStaticByteLength(schemaType);
+    const isDynamic = staticByteLength === 0;
+    const typeId = userType;
+    return {
+      schemaType,
+      renderTableType: {
+        typeId,
+        typeWithLocation: typeId,
+        enumName: SchemaType[schemaType],
+        staticByteLength,
+        isDynamic,
+        typeWrap: `${userType}`,
+        typeUnwrap: `uint8`,
+        internalTypeId: `${SchemaTypeToAbiType[schemaType]}`,
+      },
+    };
+  }
+  // invalid
+  throw new Error(`User type "${userType}" does not exist`);
+}
+
+function getStaticArrayTypeInfo(abiType: string, elementType: string, staticLength: number) {
+  const internalTypeId = elementType + "[]";
+  const schemaType = AbiTypeToSchemaType[internalTypeId];
+  return {
+    schemaType,
+    renderTableType: {
+      typeId: abiType,
+      typeWithLocation: `${abiType} memory`,
+      enumName: SchemaType[schemaType],
+      staticByteLength: 0,
+      isDynamic: true,
+      typeWrap: `toStaticArray_${elementType}_${staticLength}`,
+      typeUnwrap: `fromStaticArray_${elementType}_${staticLength}`,
+      typeWrappingData: {
+        kind: "staticArray",
+        elementType,
+        staticLength,
+      },
+      internalTypeId,
+    },
+  } as const;
+}

package/src/render-solidity/worldgen.ts

@@ -0,0 +1,60 @@
+import { readFileSync } from "fs";
+import path from "path";
+import { MUDConfig } from "../config/index.js";
+import { contractToInterface } from "../utils/contractToInterface.js";
+import { formatAndWrite } from "../utils/formatAndWrite.js";
+import { renderSystemInterface } from "./renderSystemInterface.js";
+import { renderWorld } from "./renderWorld.js";
+import { ImportDatum } from "./types.js";
+
+export async function worldgen(
+  config: MUDConfig,
+  existingContracts: { path: string; basename: string }[],
+  outputBaseDirectory: string
+) {
+  const worldgenBaseDirectory = path.join(outputBaseDirectory, config.worldgenDirectory);
+  const systems = existingContracts.filter(({ basename }) => Object.keys(config.systems).includes(basename));
+
+  const systemInterfaceImports: ImportDatum[] = [];
+  for (const system of systems) {
+    const data = readFileSync(system.path, "utf8");
+    // get external funcions from a contract
+    const { functions, symbols } = contractToInterface(data, system.basename);
+    const imports = symbols.map((symbol) => ({
+      symbol,
+      fromPath: system.path,
+      usedInPath: worldgenBaseDirectory,
+    }));
+    const systemInterfaceName = `I${system.basename}`;
+    // create an interface using the external functions and imports
+    const { fileSelector } = config.systems[system.basename];
+    const output = renderSystemInterface({
+      name: systemInterfaceName,
+      functionPrefix: config.namespace === "" ? "" : `${config.namespace}_${fileSelector}_`,
+      functions,
+      imports,
+    });
+    // write to file
+    const fullOutputPath = path.join(worldgenBaseDirectory, systemInterfaceName + ".sol");
+    await formatAndWrite(output, fullOutputPath, "Generated system interface");
+
+    // prepare imports for IWorld
+    systemInterfaceImports.push({
+      symbol: systemInterfaceName,
+      fromPath: `${systemInterfaceName}.sol`,
+      usedInPath: "./",
+    });
+  }
+
+  // render IWorld
+  const worldInterfaceName = "IWorld";
+  const output = renderWorld({
+    interfaceName: worldInterfaceName,
+    imports: systemInterfaceImports,
+    storeImportPath: config.storeImportPath,
+    worldImportPath: config.worldImportPath,
+  });
+  // write to file
+  const fullOutputPath = path.join(worldgenBaseDirectory, worldInterfaceName + ".sol");
+  await formatAndWrite(output, fullOutputPath, "Generated system interface");
+}

package/src/utils/contractToInterface.ts

@@ -0,0 +1,130 @@
+import { parse, visit } from "@solidity-parser/parser";
+import { TypeName, VariableDeclaration } from "@solidity-parser/parser/dist/src/ast-types.js";
+import { RenderSystemInterfaceFunction } from "../render-solidity/types.js";
+import { MUDError } from "./errors.js";
+
+/**
+ * Parse the contract data to get the functions necessary to generate an interface,
+ * and symbols to import from the original contract.
+ * @param data contents of a file with the solidity contract
+ * @param contractName name of the contract
+ * @returns interface data
+ */
+export function contractToInterface(data: string, contractName: string) {
+  const ast = parse(data);
+
+  let withContract = false;
+  let symbols: string[] = [];
+  const functions: RenderSystemInterfaceFunction[] = [];
+
+  visit(ast, {
+    ContractDefinition({ name }) {
+      if (name === contractName) {
+        withContract = true;
+      }
+    },
+    FunctionDefinition(
+      { name, visibility, parameters, returnParameters, isConstructor, isFallback, isReceiveEther },
+      parent
+    ) {
+      if (parent !== undefined && parent.type === "ContractDefinition" && parent.name === contractName) {
+        try {
+          // skip constructor and fallbacks
+          if (isConstructor || isFallback || isReceiveEther) return;
+          // forbid default visibility (this check might be unnecessary, modern solidity already disallows this)
+          if (visibility === "default") throw new MUDError(`Visibility is not specified`);
+
+          if (visibility === "external" || visibility === "public") {
+            functions.push({
+              name: name === null ? "" : name,
+              parameters: parameters.map(parseParameter),
+              returnParameters: returnParameters === null ? [] : returnParameters.map(parseParameter),
+            });
+
+            for (const { typeName } of parameters.concat(returnParameters ?? [])) {
+              symbols = symbols.concat(typeNameToExternalSymbols(typeName));
+            }
+          }
+        } catch (error: unknown) {
+          if (error instanceof MUDError) {
+            error.message = `Function "${name}" in contract "${contractName}": ${error.message}`;
+          }
+          throw error;
+        }
+      }
+    },
+  });
+
+  if (!withContract) {
+    throw new MUDError(`Contract not found: ${contractName}`);
+  }
+
+  return {
+    functions,
+    symbols,
+  };
+}
+
+function parseParameter({ name, typeName, storageLocation }: VariableDeclaration): string {
+  let typedNameWithLocation = "";
+
+  const { name: flattenedTypeName, stateMutability } = flattenTypeName(typeName);
+  // type name (e.g. uint256)
+  typedNameWithLocation += flattenedTypeName;
+  // optional mutability (e.g. address payable)
+  if (stateMutability !== null) {
+    typedNameWithLocation += ` ${stateMutability}`;
+  }
+  // location, when relevant (e.g. string memory)
+  if (storageLocation !== null) {
+    typedNameWithLocation += ` ${storageLocation}`;
+  }
+  // optional variable name
+  if (name !== null) {
+    typedNameWithLocation += ` ${name}`;
+  }
+
+  return typedNameWithLocation;
+}
+
+function flattenTypeName(typeName: TypeName | null): { name: string; stateMutability: string | null } {
+  if (typeName === null) {
+    return {
+      name: "",
+      stateMutability: null,
+    };
+  }
+  if (typeName.type === "ElementaryTypeName") {
+    return {
+      name: typeName.name,
+      stateMutability: typeName.stateMutability,
+    };
+  } else if (typeName.type === "UserDefinedTypeName") {
+    return {
+      name: typeName.namePath,
+      stateMutability: null,
+    };
+  } else if (typeName.type === "ArrayTypeName") {
+    const { name, stateMutability } = flattenTypeName(typeName.baseTypeName);
+    return {
+      name: `${name}[]`,
+      stateMutability,
+    };
+  } else {
+    // TODO function types are unsupported but could be useful
+    throw new MUDError(`Invalid typeName.type ${typeName.type}`);
+  }
+}
+
+// Get symbols that need to be imported for given typeName
+function typeNameToExternalSymbols(typeName: TypeName | null): string[] {
+  if (typeName?.type === "UserDefinedTypeName") {
+    // split is needed to get a library, if types are internal to it
+    const symbol = typeName.namePath.split(".")[0];
+    return [symbol];
+  } else if (typeName?.type === "ArrayTypeName") {
+    return typeNameToExternalSymbols(typeName.baseTypeName);
+  } else {
+    return [];
+  }
+}