@latticexyz/world 2.2.22-ca7a36a114ba65468662dbeef343129fa60f04eb → 2.2.22-d621dc7c427a59eb74f4d379862646355a149338

package/dist/internal.d.ts

@@ -1,5 +1,6 @@
 import { Abi, ContractFunctionName, Hex, EncodeFunctionDataParameters, Address, Chain, Account, Client, Transport, WalletActions } from 'viem';
 import { AbiParametersToPrimitiveTypes, ExtractAbiFunction } from 'abitype';
+import { SmartAccount, BundlerActions } from 'viem/account-abstraction';
 export { C as CODEGEN_DEFAULTS, b as CONFIG_DEFAULTS, k as CodegenInput, D as DEPLOY_DEFAULTS, j as DeployInput, M as MODULE_DEFAULTS, i as ModuleInput, N as NamespaceInput, h as NamespacesInput, a as SYSTEM_DEFAULTS, S as SYSTEM_DEPLOY_DEFAULTS, e as SystemDeployInput, f as SystemInput, g as SystemsInput, V as ValidateSystemOptions, W as WorldInput, o as defineNamespaces, t as defineSystem, d as defineWorld, p as requiredSystemKey, r as resolveCodegen, c as resolveDeploy, l as resolveNamespace, y as resolveNamespaceMode, n as resolveNamespaces, s as resolveSystem, w as resolveSystems, z as resolveWorld, v as validateNamespace, m as validateNamespaces, q as validateSystem, u as validateSystems, x as validateWorld } from './world-NqdA4pfW.js';
 export { C as Codegen, f as Deploy, D as DynamicResolution, M as Module, N as Namespace, e as Namespaces, c as System, S as SystemDeploy, d as Systems, V as ValueWithType, W as World, i as isDynamicResolution, a as isValueWithType, r as resolveTableId, b as resolveWithContext } from './dynamicResolution-Bul4y_B0.js';
 import '@ark/util';
@@ -159,6 +160,19 @@ declare function encodeSystemCalls<abis extends readonly Abi[]>(systemCalls: Sys
 /** Encode system calls to be passed as arguments into `World.batchCallFrom` */
 declare function encodeSystemCallsFrom<abis extends readonly Abi[]>(from: Address, systemCalls: SystemCalls<abis>): AbiParametersToPrimitiveTypes<ExtractAbiFunction<worldCallAbi, "batchCallFrom">["inputs"]>;
 
+type SystemFunction$1 = {
+    systemId: Hex;
+    systemFunctionSelector: Hex;
+};
+
+type CallFromParameters$1 = {
+    worldAddress: Hex;
+    delegatorAddress: Hex;
+    worldFunctionToSystemFunction?: (worldFunctionSelector: Hex) => Promise<SystemFunction$1>;
+    publicClient?: Client;
+};
+declare function callFrom(params: CallFromParameters$1): <chain extends Chain, account extends Account | undefined>(client: Client<Transport, chain, account>) => Pick<WalletActions<chain, account>, "writeContract">;
+
 type CallFromParameters = {
     worldAddress: Hex;
     delegatorAddress: Hex;
@@ -169,6 +183,6 @@ type SystemFunction = {
     systemId: Hex;
     systemFunctionSelector: Hex;
 };
-declare function callFrom(params: CallFromParameters): <chain extends Chain, account extends Account | undefined>(client: Client<Transport, chain, account>) => Pick<WalletActions<chain, account>, "writeContract">;
+declare function sendUserOperationFrom(params: CallFromParameters): <chain extends Chain, account extends SmartAccount | undefined>(client: Client<Transport, chain, account>) => Pick<BundlerActions<account>, "sendUserOperation">;
 
-export { type SystemCall, type SystemCallFrom, type SystemCalls, callFrom, encodeSystemCall, encodeSystemCallFrom, encodeSystemCalls, encodeSystemCallsFrom };
+export { type SystemCall, type SystemCallFrom, type SystemCalls, callFrom, encodeSystemCall, encodeSystemCallFrom, encodeSystemCalls, encodeSystemCallsFrom, sendUserOperationFrom };

package/dist/internal.js

@@ -119,57 +119,23 @@ function encodeSystemCallsFrom(from, systemCalls) {
 // ts/actions/callFrom.ts
 import {
   slice,
-  concat
+  concat as concat2
 } from "viem";
-import { getAction, encodeFunctionData as encodeFunctionData5 } from "viem/utils";
-import { readContract, writeContract as viem_writeContract } from "viem/actions";
+import { getAction as getAction2, encodeFunctionData as encodeFunctionData5 } from "viem/utils";
+import { writeContract as viem_writeContract } from "viem/actions";
 import { readHex } from "@latticexyz/common";
+
+// ts/worldFunctionToSystemFunction.ts
 import {
+  getSchemaTypes,
   getKeySchema,
   getValueSchema,
-  getSchemaTypes,
-  decodeValueArgs,
-  encodeKey
+  encodeKey,
+  decodeValueArgs
 } from "@latticexyz/protocol-parser/internal";
-function callFrom(params) {
-  return (client) => ({
-    async writeContract(writeArgs) {
-      const _writeContract = getAction(client, viem_writeContract, "writeContract");
-      if (writeArgs.address !== params.worldAddress || writeArgs.functionName === "call" || writeArgs.functionName === "callFrom" || writeArgs.functionName === "batchCallFrom" || writeArgs.functionName === "callWithSignature") {
-        return _writeContract(writeArgs);
-      }
-      if (writeArgs.functionName === "batchCall") {
-        const batchCallArgs = writeArgs;
-        const [systemCalls] = batchCallArgs.args;
-        if (!systemCalls.length) {
-          throw new Error("`batchCall` should have at least one system call.");
-        }
-        return _writeContract({
-          ...batchCallArgs,
-          functionName: "batchCallFrom",
-          args: [systemCalls.map((systemCall) => ({ from: params.delegatorAddress, ...systemCall }))]
-        });
-      }
-      const worldCalldata = encodeFunctionData5({
-        abi: writeArgs.abi,
-        functionName: writeArgs.functionName,
-        args: writeArgs.args
-      });
-      const worldFunctionSelector = slice(worldCalldata, 0, 4);
-      const { systemId, systemFunctionSelector } = await worldFunctionToSystemFunction({
-        ...params,
-        publicClient: params.publicClient ?? client,
-        worldFunctionSelector
-      });
-      const systemCalldata = concat([systemFunctionSelector, readHex(worldCalldata, 4)]);
-      return _writeContract({
-        ...writeArgs,
-        functionName: "callFrom",
-        args: [params.delegatorAddress, systemId, systemCalldata]
-      });
-    }
-  });
-}
+import { concat } from "viem";
+import { readContract } from "viem/actions";
+import { getAction } from "viem/utils";
 var systemFunctionCache = /* @__PURE__ */ new Map();
 async function worldFunctionToSystemFunction(params) {
   const cacheKey = concat([params.worldAddress, params.worldFunctionSelector]);
@@ -233,6 +199,107 @@ async function retrieveSystemFunctionFromContract(publicClient, worldAddress, wo
   return systemFunction;
 }
 
+// ts/actions/callFrom.ts
+function callFrom(params) {
+  return (client) => ({
+    async writeContract(writeArgs) {
+      const _writeContract = getAction2(client, viem_writeContract, "writeContract");
+      if (writeArgs.address !== params.worldAddress || writeArgs.functionName === "call" || writeArgs.functionName === "callFrom" || writeArgs.functionName === "batchCallFrom" || writeArgs.functionName === "callWithSignature") {
+        return _writeContract(writeArgs);
+      }
+      if (writeArgs.functionName === "batchCall") {
+        const batchCallArgs = writeArgs;
+        const [systemCalls] = batchCallArgs.args;
+        if (!systemCalls.length) {
+          throw new Error("`batchCall` should have at least one system call.");
+        }
+        return _writeContract({
+          ...batchCallArgs,
+          functionName: "batchCallFrom",
+          args: [systemCalls.map((systemCall) => ({ from: params.delegatorAddress, ...systemCall }))]
+        });
+      }
+      const worldCalldata = encodeFunctionData5({
+        abi: writeArgs.abi,
+        functionName: writeArgs.functionName,
+        args: writeArgs.args
+      });
+      const worldFunctionSelector = slice(worldCalldata, 0, 4);
+      const { systemId, systemFunctionSelector } = await worldFunctionToSystemFunction({
+        ...params,
+        publicClient: params.publicClient ?? client,
+        worldFunctionSelector
+      });
+      const systemCalldata = concat2([systemFunctionSelector, readHex(worldCalldata, 4)]);
+      return _writeContract({
+        ...writeArgs,
+        functionName: "callFrom",
+        args: [params.delegatorAddress, systemId, systemCalldata]
+      });
+    }
+  });
+}
+
+// ts/actions/sendUserOperationFrom.ts
+import {
+  slice as slice2,
+  concat as concat3
+} from "viem";
+import { getAction as getAction3, encodeFunctionData as encodeFunctionData6 } from "viem/utils";
+import { readHex as readHex2 } from "@latticexyz/common";
+import { sendUserOperation as viem_sendUserOperation } from "viem/account-abstraction";
+function sendUserOperationFrom(params) {
+  return (client) => ({
+    async sendUserOperation(args) {
+      const _sendUserOperation = getAction3(client, viem_sendUserOperation, "sendUserOperation");
+      if (args.callData) {
+        return _sendUserOperation(args);
+      }
+      const calls = await Promise.all(
+        args.calls.map(async (call) => {
+          if (!isDecodedCall(call)) return call;
+          if (call.to !== params.worldAddress || call.functionName === "call" || call.functionName === "callFrom" || call.functionName === "batchCallFrom" || call.functionName === "callWithSignature") {
+            return call;
+          }
+          if (call.functionName === "batchCall") {
+            const batchCallArgs = call.args;
+            const [systemCalls] = batchCallArgs.args;
+            if (!systemCalls.length) {
+              throw new Error("`batchCall` should have at least one system call.");
+            }
+            return {
+              ...call,
+              functionName: "batchCallFrom",
+              args: [systemCalls.map((systemCall) => ({ from: params.delegatorAddress, ...systemCall }))]
+            };
+          }
+          const worldCalldata = encodeFunctionData6({
+            abi: call.abi,
+            functionName: call.functionName,
+            args: call.args
+          });
+          const worldFunctionSelector = slice2(worldCalldata, 0, 4);
+          const { systemId, systemFunctionSelector } = await worldFunctionToSystemFunction({
+            ...params,
+            publicClient: params.publicClient ?? client,
+            worldFunctionSelector
+          });
+          const systemCalldata = concat3([systemFunctionSelector, readHex2(worldCalldata, 4)]);
+          return {
+            ...call,
+            functionName: "callFrom",
+            args: [params.delegatorAddress, systemId, systemCalldata]
+          };
+        })
+      );
+      return _sendUserOperation({ ...args, calls });
+    }
+  });
+}
+function isDecodedCall(call) {
+  return typeof call === "object" && call != null && "functionName" in call && "args" in call && "to" in call;
+}
+
 // ts/config/v2/dynamicResolution.ts
 function resolveTableId(tableName) {
   return {
@@ -294,6 +361,7 @@ export {
   resolveTableId,
   resolveWithContext,
   resolveWorld,
+  sendUserOperationFrom,
   validateNamespace,
   validateNamespaces,
   validateSystem,

package/dist/internal.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../ts/encodeSystemCall.ts","../ts/normalizeSystemFunctionName.ts","../ts/encodeSystemCallFrom.ts","../ts/encodeSystemCalls.ts","../ts/encodeSystemCallsFrom.ts","../ts/actions/callFrom.ts","../ts/config/v2/dynamicResolution.ts"],"sourcesContent":["import { Abi, EncodeFunctionDataParameters, Hex, encodeFunctionData, type ContractFunctionName } from \"viem\";\nimport type { AbiParametersToPrimitiveTypes, ExtractAbiFunction } from \"abitype\";\nimport { worldCallAbi } from \"./worldCallAbi\";\nimport { internal_normalizeSystemFunctionName } from \"./normalizeSystemFunctionName\";\n\nexport type SystemCall<abi extends Abi, functionName extends ContractFunctionName<abi>> = {\n  [k in ContractFunctionName<abi>]: {\n    /**\n     * System's resource ID\n     */\n    readonly systemId: Hex;\n    /**\n     * System ABI\n     */\n    readonly abi: abi;\n    /**\n     * System function name to call\n     */\n    readonly functionName: k;\n  } & Pick<EncodeFunctionDataParameters<abi, k>, \"args\">;\n}[functionName];\n\n/** Encode a system call to be passed as arguments into `World.call` */\nexport function encodeSystemCall<abi extends Abi, functionName extends ContractFunctionName<abi>>({\n  abi,\n  systemId,\n  functionName,\n  args,\n}: SystemCall<abi, functionName>): AbiParametersToPrimitiveTypes<ExtractAbiFunction<worldCallAbi, \"call\">[\"inputs\"]> {\n  return [\n    systemId,\n    encodeFunctionData<abi, functionName>({\n      abi,\n      functionName: internal_normalizeSystemFunctionName(systemId, functionName),\n      args,\n    } as EncodeFunctionDataParameters<abi, functionName>),\n  ];\n}\n","import { hexToResource, resourceToLabel } from \"@latticexyz/common\";\nimport { Hex } from \"viem\";\n\n/** @internal */\nexport function internal_normalizeSystemFunctionName(systemId: Hex, functionName: string) {\n  const resource = hexToResource(systemId);\n  const worldFunctionPrefix = resource.namespace !== \"\" ? `${resource.namespace}__` : null;\n  if (worldFunctionPrefix != null && functionName.startsWith(worldFunctionPrefix)) {\n    console.warn(\n      // eslint-disable-next-line max-len\n      `Detected world function name \"${functionName}\" used in call to system \"${resourceToLabel(resource)}\".\\n\\nIt's recommended to use a system ABI and system function name with these methods instead.`,\n    );\n    return functionName.slice(worldFunctionPrefix.length);\n  }\n  return functionName;\n}\n","import { Abi, EncodeFunctionDataParameters, encodeFunctionData, Address, type ContractFunctionName } from \"viem\";\nimport type { AbiParametersToPrimitiveTypes, ExtractAbiFunction } from \"abitype\";\nimport { SystemCall } from \"./encodeSystemCall\";\nimport { worldCallAbi } from \"./worldCallAbi\";\nimport { internal_normalizeSystemFunctionName } from \"./normalizeSystemFunctionName\";\n\nexport type SystemCallFrom<abi extends Abi, functionName extends ContractFunctionName<abi>> = SystemCall<\n  abi,\n  functionName\n> & {\n  readonly from: Address;\n};\n\n/** Encode a system call to be passed as arguments into `World.callFrom` */\nexport function encodeSystemCallFrom<abi extends Abi, functionName extends ContractFunctionName<abi>>({\n  abi,\n  from,\n  systemId,\n  functionName,\n  args,\n}: SystemCallFrom<abi, functionName>): AbiParametersToPrimitiveTypes<\n  ExtractAbiFunction<worldCallAbi, \"callFrom\">[\"inputs\"]\n> {\n  return [\n    from,\n    systemId,\n    encodeFunctionData<abi, functionName>({\n      abi,\n      functionName: internal_normalizeSystemFunctionName(systemId, functionName),\n      args,\n    } as EncodeFunctionDataParameters<abi, functionName>),\n  ];\n}\n","import { Abi, encodeFunctionData, type ContractFunctionName } from \"viem\";\nimport { SystemCall } from \"./encodeSystemCall\";\nimport type { AbiParametersToPrimitiveTypes, ExtractAbiFunction } from \"abitype\";\nimport { worldCallAbi } from \"./worldCallAbi\";\nimport { internal_normalizeSystemFunctionName } from \"./normalizeSystemFunctionName\";\n\nexport type SystemCalls<abis extends readonly Abi[]> = {\n  [k in keyof abis]: SystemCall<abis[k], ContractFunctionName<abis[k]>>;\n};\n\n/** Encode system calls to be passed as arguments into `World.batchCall` */\nexport function encodeSystemCalls<abis extends readonly Abi[]>(\n  systemCalls: SystemCalls<abis>,\n): AbiParametersToPrimitiveTypes<ExtractAbiFunction<worldCallAbi, \"batchCall\">[\"inputs\"]> {\n  return [\n    systemCalls.map(({ abi, systemId, functionName, args }) => ({\n      systemId,\n      callData: encodeFunctionData({\n        abi,\n        functionName: internal_normalizeSystemFunctionName(systemId, functionName),\n        args,\n      }),\n    })),\n  ];\n}\n","import { Abi, Address, encodeFunctionData } from \"viem\";\nimport type { AbiParametersToPrimitiveTypes, ExtractAbiFunction } from \"abitype\";\nimport { worldCallAbi } from \"./worldCallAbi\";\nimport { internal_normalizeSystemFunctionName } from \"./normalizeSystemFunctionName\";\nimport { SystemCalls } from \"./encodeSystemCalls\";\n\n/** Encode system calls to be passed as arguments into `World.batchCallFrom` */\nexport function encodeSystemCallsFrom<abis extends readonly Abi[]>(\n  from: Address,\n  systemCalls: SystemCalls<abis>,\n): AbiParametersToPrimitiveTypes<ExtractAbiFunction<worldCallAbi, \"batchCallFrom\">[\"inputs\"]> {\n  return [\n    systemCalls.map(({ abi, systemId, functionName, args }) => ({\n      from,\n      systemId,\n      callData: encodeFunctionData({\n        abi,\n        functionName: internal_normalizeSystemFunctionName(systemId, functionName),\n        args,\n      }),\n    })),\n  ];\n}\n","import {\n  slice,\n  concat,\n  type Transport,\n  type Chain,\n  type Account,\n  type Hex,\n  type WalletActions,\n  type Client,\n  type PublicActions,\n  type WriteContractParameters,\n  type EncodeFunctionDataParameters,\n} from \"viem\";\nimport { getAction, encodeFunctionData } from \"viem/utils\";\nimport { readContract, writeContract as viem_writeContract } from \"viem/actions\";\nimport { readHex } from \"@latticexyz/common\";\nimport {\n  getKeySchema,\n  getValueSchema,\n  getSchemaTypes,\n  decodeValueArgs,\n  encodeKey,\n} from \"@latticexyz/protocol-parser/internal\";\nimport worldConfig from \"../../mud.config\";\nimport { worldCallAbi } from \"../worldCallAbi\";\n\ntype CallFromParameters = {\n  worldAddress: Hex;\n  delegatorAddress: Hex;\n  worldFunctionToSystemFunction?: (worldFunctionSelector: Hex) => Promise<SystemFunction>;\n  publicClient?: Client;\n};\n\ntype SystemFunction = { systemId: Hex; systemFunctionSelector: Hex };\n\n// By extending viem clients with this function after delegation, the delegation is automatically applied to World contract writes.\n// This means that these writes are made on behalf of the delegator.\n// Internally, it transforms the write arguments to use `callFrom`.\n//\n// Accepts either `worldFunctionToSystemFunction` or `publicClient` as an argument.\n// `worldFunctionToSystemFunction` allows manually providing the mapping function, thus users can utilize their client store for the lookup.\n// If `publicClient` is provided instead, this function retrieves the corresponding system function from the World contract.\n//\n// The function mapping is cached to avoid redundant retrievals for the same World function.\nexport function callFrom(\n  params: CallFromParameters,\n): <chain extends Chain, account extends Account | undefined>(\n  client: Client<Transport, chain, account>,\n) => Pick<WalletActions<chain, account>, \"writeContract\"> {\n  return (client) => ({\n    async writeContract(writeArgs) {\n      const _writeContract = getAction(client, viem_writeContract, \"writeContract\");\n\n      // Skip if the contract isn't the World or the function called should not be redirected through `callFrom`.\n      if (\n        writeArgs.address !== params.worldAddress ||\n        writeArgs.functionName === \"call\" ||\n        writeArgs.functionName === \"callFrom\" ||\n        writeArgs.functionName === \"batchCallFrom\" ||\n        writeArgs.functionName === \"callWithSignature\"\n      ) {\n        return _writeContract(writeArgs);\n      }\n\n      // Wrap system calls from `batchCall` with delegator for a `batchCallFrom`\n      // TODO: remove this specific workaround once https://github.com/latticexyz/mud/pull/3506 lands\n      if (writeArgs.functionName === \"batchCall\") {\n        const batchCallArgs = writeArgs as unknown as WriteContractParameters<worldCallAbi, \"batchCall\">;\n        const [systemCalls] = batchCallArgs.args;\n        if (!systemCalls.length) {\n          throw new Error(\"`batchCall` should have at least one system call.\");\n        }\n\n        return _writeContract({\n          ...batchCallArgs,\n          functionName: \"batchCallFrom\",\n          args: [systemCalls.map((systemCall) => ({ from: params.delegatorAddress, ...systemCall }))],\n        });\n      }\n\n      // Encode the World's calldata (which includes the World's function selector).\n      const worldCalldata = encodeFunctionData({\n        abi: writeArgs.abi,\n        functionName: writeArgs.functionName,\n        args: writeArgs.args,\n      } as unknown as EncodeFunctionDataParameters);\n\n      // The first 4 bytes of calldata represent the function selector.\n      const worldFunctionSelector = slice(worldCalldata, 0, 4);\n\n      // Get the systemId and System's function selector.\n      const { systemId, systemFunctionSelector } = await worldFunctionToSystemFunction({\n        ...params,\n        publicClient: params.publicClient ?? client,\n        worldFunctionSelector,\n      });\n\n      // Construct the System's calldata by replacing the World's function selector with the System's.\n      // Use `readHex` instead of `slice` to prevent out-of-bounds errors with calldata that has no args.\n      const systemCalldata = concat([systemFunctionSelector, readHex(worldCalldata, 4)]);\n\n      // Call `writeContract` with the new args.\n      return _writeContract({\n        ...(writeArgs as unknown as WriteContractParameters<worldCallAbi, \"callFrom\">),\n        functionName: \"callFrom\",\n        args: [params.delegatorAddress, systemId, systemCalldata],\n      });\n    },\n  });\n}\n\nconst systemFunctionCache = new Map<Hex, SystemFunction>();\n\nasync function worldFunctionToSystemFunction(params: {\n  worldAddress: Hex;\n  delegatorAddress: Hex;\n  worldFunctionSelector: Hex;\n  worldFunctionToSystemFunction?: (worldFunctionSelector: Hex) => Promise<SystemFunction>;\n  publicClient: Client;\n}): Promise<SystemFunction> {\n  const cacheKey = concat([params.worldAddress, params.worldFunctionSelector]);\n\n  // Use cache if the function has been called previously.\n  const cached = systemFunctionCache.get(cacheKey);\n  if (cached) return cached;\n\n  // If a mapping function is provided, use it. Otherwise, call the World contract.\n  const systemFunction = params.worldFunctionToSystemFunction\n    ? await params.worldFunctionToSystemFunction(params.worldFunctionSelector)\n    : await retrieveSystemFunctionFromContract(params.publicClient, params.worldAddress, params.worldFunctionSelector);\n\n  systemFunctionCache.set(cacheKey, systemFunction);\n\n  return systemFunction;\n}\n\nasync function retrieveSystemFunctionFromContract(\n  publicClient: Client,\n  worldAddress: Hex,\n  worldFunctionSelector: Hex,\n): Promise<SystemFunction> {\n  const table = worldConfig.tables.world__FunctionSelectors;\n\n  const keySchema = getSchemaTypes(getKeySchema(table));\n  const valueSchema = getSchemaTypes(getValueSchema(table));\n\n  const _readContract = getAction(publicClient, readContract, \"readContract\") as PublicActions[\"readContract\"];\n\n  const [staticData, encodedLengths, dynamicData] = await _readContract({\n    address: worldAddress,\n    abi: [\n      {\n        type: \"function\",\n        name: \"getRecord\",\n        inputs: [\n          {\n            name: \"tableId\",\n            type: \"bytes32\",\n            internalType: \"ResourceId\",\n          },\n          {\n            name: \"keyTuple\",\n            type: \"bytes32[]\",\n            internalType: \"bytes32[]\",\n          },\n        ],\n        outputs: [\n          {\n            name: \"staticData\",\n            type: \"bytes\",\n            internalType: \"bytes\",\n          },\n          {\n            name: \"encodedLengths\",\n            type: \"bytes32\",\n            internalType: \"EncodedLengths\",\n          },\n          {\n            name: \"dynamicData\",\n            type: \"bytes\",\n            internalType: \"bytes\",\n          },\n        ],\n        stateMutability: \"view\",\n      },\n    ],\n    functionName: \"getRecord\",\n    args: [table.tableId, encodeKey(keySchema, { worldFunctionSelector })],\n  });\n\n  const decoded = decodeValueArgs(valueSchema, { staticData, encodedLengths, dynamicData });\n\n  const systemFunction: SystemFunction = {\n    systemId: decoded.systemId,\n    systemFunctionSelector: decoded.systemFunctionSelector,\n  };\n\n  return systemFunction;\n}\n","import { World } from \"./output\";\n\nexport type DynamicResolution = {\n  // TODO: add systemAddress support\n  type: \"tableId\";\n  input: string;\n};\n\nexport type ValueWithType = {\n  value: string | number | Uint8Array;\n  type: string;\n};\n\n/**\n * Dynamically resolve a table name to a table id at deploy time\n */\nexport function resolveTableId(tableName: string) {\n  return {\n    type: \"tableId\",\n    input: tableName,\n  } as const;\n}\n\n/** Type guard for DynamicResolution */\nexport function isDynamicResolution(value: unknown): value is DynamicResolution {\n  return typeof value === \"object\" && value !== null && \"type\" in value && \"input\" in value;\n}\n\n/** Type guard for ValueWithType */\nexport function isValueWithType(value: unknown): value is ValueWithType {\n  return typeof value === \"object\" && value !== null && \"type\" in value && \"value\" in value;\n}\n\n/**\n * Turn a DynamicResolution object into a ValueWithType based on the provided context\n */\nexport function resolveWithContext(\n  input: unknown,\n  context: { config: World; systemAddresses?: Record<string, Promise<string>> },\n): ValueWithType {\n  if (isValueWithType(input)) return input;\n\n  if (isDynamicResolution(input)) {\n    if (input.type === \"tableId\") {\n      const tableEntries = Object.entries(context.config.tables).filter(\n        ([tableName, table]) => tableName === input.input || table.name === input.input,\n      );\n\n      if (tableEntries.length > 1) {\n        throw new Error(\n          `Found more than one table with name \"${input.input}\". Try using one of the following table names instead: ${tableEntries.map(([tableName]) => tableName).join(\", \")}`,\n        );\n      }\n\n      if (tableEntries.length === 1) {\n        const [entry] = tableEntries;\n        const [, table] = entry;\n        return { type: \"bytes32\", value: table.tableId };\n      }\n    }\n  }\n\n  throw new Error(`Could not resolve dynamic resolution:\\n${JSON.stringify(input, null, 2)}`);\n}\n"],"mappings":"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","names":["encodeFunctionData","encodeFunctionData","encodeFunctionData","encodeFunctionData","encodeFunctionData","encodeFunctionData","encodeFunctionData","encodeFunctionData"]}
+{"version":3,"sources":["../ts/encodeSystemCall.ts","../ts/normalizeSystemFunctionName.ts","../ts/encodeSystemCallFrom.ts","../ts/encodeSystemCalls.ts","../ts/encodeSystemCallsFrom.ts","../ts/actions/callFrom.ts","../ts/worldFunctionToSystemFunction.ts","../ts/actions/sendUserOperationFrom.ts","../ts/config/v2/dynamicResolution.ts"],"sourcesContent":["import { Abi, EncodeFunctionDataParameters, Hex, encodeFunctionData, type ContractFunctionName } from \"viem\";\nimport type { AbiParametersToPrimitiveTypes, ExtractAbiFunction } from \"abitype\";\nimport { worldCallAbi } from \"./worldCallAbi\";\nimport { internal_normalizeSystemFunctionName } from \"./normalizeSystemFunctionName\";\n\nexport type SystemCall<abi extends Abi, functionName extends ContractFunctionName<abi>> = {\n  [k in ContractFunctionName<abi>]: {\n    /**\n     * System's resource ID\n     */\n    readonly systemId: Hex;\n    /**\n     * System ABI\n     */\n    readonly abi: abi;\n    /**\n     * System function name to call\n     */\n    readonly functionName: k;\n  } & Pick<EncodeFunctionDataParameters<abi, k>, \"args\">;\n}[functionName];\n\n/** Encode a system call to be passed as arguments into `World.call` */\nexport function encodeSystemCall<abi extends Abi, functionName extends ContractFunctionName<abi>>({\n  abi,\n  systemId,\n  functionName,\n  args,\n}: SystemCall<abi, functionName>): AbiParametersToPrimitiveTypes<ExtractAbiFunction<worldCallAbi, \"call\">[\"inputs\"]> {\n  return [\n    systemId,\n    encodeFunctionData<abi, functionName>({\n      abi,\n      functionName: internal_normalizeSystemFunctionName(systemId, functionName),\n      args,\n    } as EncodeFunctionDataParameters<abi, functionName>),\n  ];\n}\n","import { hexToResource, resourceToLabel } from \"@latticexyz/common\";\nimport { Hex } from \"viem\";\n\n/** @internal */\nexport function internal_normalizeSystemFunctionName(systemId: Hex, functionName: string) {\n  const resource = hexToResource(systemId);\n  const worldFunctionPrefix = resource.namespace !== \"\" ? `${resource.namespace}__` : null;\n  if (worldFunctionPrefix != null && functionName.startsWith(worldFunctionPrefix)) {\n    console.warn(\n      // eslint-disable-next-line max-len\n      `Detected world function name \"${functionName}\" used in call to system \"${resourceToLabel(resource)}\".\\n\\nIt's recommended to use a system ABI and system function name with these methods instead.`,\n    );\n    return functionName.slice(worldFunctionPrefix.length);\n  }\n  return functionName;\n}\n","import { Abi, EncodeFunctionDataParameters, encodeFunctionData, Address, type ContractFunctionName } from \"viem\";\nimport type { AbiParametersToPrimitiveTypes, ExtractAbiFunction } from \"abitype\";\nimport { SystemCall } from \"./encodeSystemCall\";\nimport { worldCallAbi } from \"./worldCallAbi\";\nimport { internal_normalizeSystemFunctionName } from \"./normalizeSystemFunctionName\";\n\nexport type SystemCallFrom<abi extends Abi, functionName extends ContractFunctionName<abi>> = SystemCall<\n  abi,\n  functionName\n> & {\n  readonly from: Address;\n};\n\n/** Encode a system call to be passed as arguments into `World.callFrom` */\nexport function encodeSystemCallFrom<abi extends Abi, functionName extends ContractFunctionName<abi>>({\n  abi,\n  from,\n  systemId,\n  functionName,\n  args,\n}: SystemCallFrom<abi, functionName>): AbiParametersToPrimitiveTypes<\n  ExtractAbiFunction<worldCallAbi, \"callFrom\">[\"inputs\"]\n> {\n  return [\n    from,\n    systemId,\n    encodeFunctionData<abi, functionName>({\n      abi,\n      functionName: internal_normalizeSystemFunctionName(systemId, functionName),\n      args,\n    } as EncodeFunctionDataParameters<abi, functionName>),\n  ];\n}\n","import { Abi, encodeFunctionData, type ContractFunctionName } from \"viem\";\nimport { SystemCall } from \"./encodeSystemCall\";\nimport type { AbiParametersToPrimitiveTypes, ExtractAbiFunction } from \"abitype\";\nimport { worldCallAbi } from \"./worldCallAbi\";\nimport { internal_normalizeSystemFunctionName } from \"./normalizeSystemFunctionName\";\n\nexport type SystemCalls<abis extends readonly Abi[]> = {\n  [k in keyof abis]: SystemCall<abis[k], ContractFunctionName<abis[k]>>;\n};\n\n/** Encode system calls to be passed as arguments into `World.batchCall` */\nexport function encodeSystemCalls<abis extends readonly Abi[]>(\n  systemCalls: SystemCalls<abis>,\n): AbiParametersToPrimitiveTypes<ExtractAbiFunction<worldCallAbi, \"batchCall\">[\"inputs\"]> {\n  return [\n    systemCalls.map(({ abi, systemId, functionName, args }) => ({\n      systemId,\n      callData: encodeFunctionData({\n        abi,\n        functionName: internal_normalizeSystemFunctionName(systemId, functionName),\n        args,\n      }),\n    })),\n  ];\n}\n","import { Abi, Address, encodeFunctionData } from \"viem\";\nimport type { AbiParametersToPrimitiveTypes, ExtractAbiFunction } from \"abitype\";\nimport { worldCallAbi } from \"./worldCallAbi\";\nimport { internal_normalizeSystemFunctionName } from \"./normalizeSystemFunctionName\";\nimport { SystemCalls } from \"./encodeSystemCalls\";\n\n/** Encode system calls to be passed as arguments into `World.batchCallFrom` */\nexport function encodeSystemCallsFrom<abis extends readonly Abi[]>(\n  from: Address,\n  systemCalls: SystemCalls<abis>,\n): AbiParametersToPrimitiveTypes<ExtractAbiFunction<worldCallAbi, \"batchCallFrom\">[\"inputs\"]> {\n  return [\n    systemCalls.map(({ abi, systemId, functionName, args }) => ({\n      from,\n      systemId,\n      callData: encodeFunctionData({\n        abi,\n        functionName: internal_normalizeSystemFunctionName(systemId, functionName),\n        args,\n      }),\n    })),\n  ];\n}\n","import {\n  slice,\n  concat,\n  type Transport,\n  type Chain,\n  type Account,\n  type Hex,\n  type WalletActions,\n  type Client,\n  type WriteContractParameters,\n  type EncodeFunctionDataParameters,\n} from \"viem\";\nimport { getAction, encodeFunctionData } from \"viem/utils\";\nimport { writeContract as viem_writeContract } from \"viem/actions\";\nimport { readHex } from \"@latticexyz/common\";\nimport { worldCallAbi } from \"../worldCallAbi\";\nimport { SystemFunction, worldFunctionToSystemFunction } from \"../worldFunctionToSystemFunction\";\n\ntype CallFromParameters = {\n  worldAddress: Hex;\n  delegatorAddress: Hex;\n  worldFunctionToSystemFunction?: (worldFunctionSelector: Hex) => Promise<SystemFunction>;\n  publicClient?: Client;\n};\n\n// By extending viem clients with this function after delegation, the delegation is automatically applied to World contract writes.\n// This means that these writes are made on behalf of the delegator.\n// Internally, it transforms the write arguments to use `callFrom`.\n//\n// Accepts either `worldFunctionToSystemFunction` or `publicClient` as an argument.\n// `worldFunctionToSystemFunction` allows manually providing the mapping function, thus users can utilize their client store for the lookup.\n// If `publicClient` is provided instead, this function retrieves the corresponding system function from the World contract.\n//\n// The function mapping is cached to avoid redundant retrievals for the same World function.\nexport function callFrom(\n  params: CallFromParameters,\n): <chain extends Chain, account extends Account | undefined>(\n  client: Client<Transport, chain, account>,\n) => Pick<WalletActions<chain, account>, \"writeContract\"> {\n  return (client) => ({\n    async writeContract(writeArgs) {\n      const _writeContract = getAction(client, viem_writeContract, \"writeContract\");\n\n      // Skip if the contract isn't the World or the function called should not be redirected through `callFrom`.\n      if (\n        writeArgs.address !== params.worldAddress ||\n        writeArgs.functionName === \"call\" ||\n        writeArgs.functionName === \"callFrom\" ||\n        writeArgs.functionName === \"batchCallFrom\" ||\n        writeArgs.functionName === \"callWithSignature\"\n      ) {\n        return _writeContract(writeArgs);\n      }\n\n      // Wrap system calls from `batchCall` with delegator for a `batchCallFrom`\n      // TODO: remove this specific workaround once https://github.com/latticexyz/mud/pull/3506 lands\n      if (writeArgs.functionName === \"batchCall\") {\n        const batchCallArgs = writeArgs as unknown as WriteContractParameters<worldCallAbi, \"batchCall\">;\n        const [systemCalls] = batchCallArgs.args;\n        if (!systemCalls.length) {\n          throw new Error(\"`batchCall` should have at least one system call.\");\n        }\n\n        return _writeContract({\n          ...batchCallArgs,\n          functionName: \"batchCallFrom\",\n          args: [systemCalls.map((systemCall) => ({ from: params.delegatorAddress, ...systemCall }))],\n        });\n      }\n\n      // Encode the World's calldata (which includes the World's function selector).\n      const worldCalldata = encodeFunctionData({\n        abi: writeArgs.abi,\n        functionName: writeArgs.functionName,\n        args: writeArgs.args,\n      } as unknown as EncodeFunctionDataParameters);\n\n      // The first 4 bytes of calldata represent the function selector.\n      const worldFunctionSelector = slice(worldCalldata, 0, 4);\n\n      // Get the systemId and System's function selector.\n      const { systemId, systemFunctionSelector } = await worldFunctionToSystemFunction({\n        ...params,\n        publicClient: params.publicClient ?? client,\n        worldFunctionSelector,\n      });\n\n      // Construct the System's calldata by replacing the World's function selector with the System's.\n      // Use `readHex` instead of `slice` to prevent out-of-bounds errors with calldata that has no args.\n      const systemCalldata = concat([systemFunctionSelector, readHex(worldCalldata, 4)]);\n\n      // Call `writeContract` with the new args.\n      return _writeContract({\n        ...(writeArgs as unknown as WriteContractParameters<worldCallAbi, \"callFrom\">),\n        functionName: \"callFrom\",\n        args: [params.delegatorAddress, systemId, systemCalldata],\n      });\n    },\n  });\n}\n","import {\n  getSchemaTypes,\n  getKeySchema,\n  getValueSchema,\n  encodeKey,\n  decodeValueArgs,\n} from \"@latticexyz/protocol-parser/internal\";\nimport { Client, concat, Hex, PublicActions } from \"viem\";\nimport { readContract } from \"viem/actions\";\nimport { getAction } from \"viem/utils\";\nimport worldConfig from \"../mud.config\";\n\nexport type SystemFunction = { systemId: Hex; systemFunctionSelector: Hex };\n\nconst systemFunctionCache = new Map<Hex, SystemFunction>();\n\nexport async function worldFunctionToSystemFunction(params: {\n  worldAddress: Hex;\n  delegatorAddress: Hex;\n  worldFunctionSelector: Hex;\n  worldFunctionToSystemFunction?: (worldFunctionSelector: Hex) => Promise<SystemFunction>;\n  publicClient: Client;\n}): Promise<SystemFunction> {\n  const cacheKey = concat([params.worldAddress, params.worldFunctionSelector]);\n\n  // Use cache if the function has been called previously.\n  const cached = systemFunctionCache.get(cacheKey);\n  if (cached) return cached;\n\n  // If a mapping function is provided, use it. Otherwise, call the World contract.\n  const systemFunction = params.worldFunctionToSystemFunction\n    ? await params.worldFunctionToSystemFunction(params.worldFunctionSelector)\n    : await retrieveSystemFunctionFromContract(params.publicClient, params.worldAddress, params.worldFunctionSelector);\n\n  systemFunctionCache.set(cacheKey, systemFunction);\n\n  return systemFunction;\n}\n\nasync function retrieveSystemFunctionFromContract(\n  publicClient: Client,\n  worldAddress: Hex,\n  worldFunctionSelector: Hex,\n): Promise<SystemFunction> {\n  const table = worldConfig.tables.world__FunctionSelectors;\n\n  const keySchema = getSchemaTypes(getKeySchema(table));\n  const valueSchema = getSchemaTypes(getValueSchema(table));\n\n  const _readContract = getAction(publicClient, readContract, \"readContract\") as PublicActions[\"readContract\"];\n\n  const [staticData, encodedLengths, dynamicData] = await _readContract({\n    address: worldAddress,\n    abi: [\n      {\n        type: \"function\",\n        name: \"getRecord\",\n        inputs: [\n          {\n            name: \"tableId\",\n            type: \"bytes32\",\n            internalType: \"ResourceId\",\n          },\n          {\n            name: \"keyTuple\",\n            type: \"bytes32[]\",\n            internalType: \"bytes32[]\",\n          },\n        ],\n        outputs: [\n          {\n            name: \"staticData\",\n            type: \"bytes\",\n            internalType: \"bytes\",\n          },\n          {\n            name: \"encodedLengths\",\n            type: \"bytes32\",\n            internalType: \"EncodedLengths\",\n          },\n          {\n            name: \"dynamicData\",\n            type: \"bytes\",\n            internalType: \"bytes\",\n          },\n        ],\n        stateMutability: \"view\",\n      },\n    ],\n    functionName: \"getRecord\",\n    args: [table.tableId, encodeKey(keySchema, { worldFunctionSelector })],\n  });\n\n  const decoded = decodeValueArgs(valueSchema, { staticData, encodedLengths, dynamicData });\n\n  const systemFunction: SystemFunction = {\n    systemId: decoded.systemId,\n    systemFunctionSelector: decoded.systemFunctionSelector,\n  };\n\n  return systemFunction;\n}\n","import {\n  slice,\n  concat,\n  type Transport,\n  type Chain,\n  type Hex,\n  type Client,\n  type EncodeFunctionDataParameters,\n  Abi,\n  WriteContractParameters,\n} from \"viem\";\nimport { getAction, encodeFunctionData } from \"viem/utils\";\nimport { readHex } from \"@latticexyz/common\";\nimport { BundlerActions, sendUserOperation as viem_sendUserOperation, SmartAccount } from \"viem/account-abstraction\";\nimport { worldFunctionToSystemFunction } from \"../worldFunctionToSystemFunction\";\nimport { worldCallAbi } from \"../worldCallAbi\";\n\ntype CallFromParameters = {\n  worldAddress: Hex;\n  delegatorAddress: Hex;\n  worldFunctionToSystemFunction?: (worldFunctionSelector: Hex) => Promise<SystemFunction>;\n  publicClient?: Client;\n};\n\ntype SystemFunction = { systemId: Hex; systemFunctionSelector: Hex };\n\n// By extending viem clients with this function after delegation, the delegation is automatically applied to World contract writes.\n// This means that these writes are made on behalf of the delegator.\n// Internally, it transforms the write arguments to use `callFrom`.\n//\n// Accepts either `worldFunctionToSystemFunction` or `publicClient` as an argument.\n// `worldFunctionToSystemFunction` allows manually providing the mapping function, thus users can utilize their client store for the lookup.\n// If `publicClient` is provided instead, this function retrieves the corresponding system function from the World contract.\n//\n// The function mapping is cached to avoid redundant retrievals for the same World function.\nexport function sendUserOperationFrom(\n  params: CallFromParameters,\n): <chain extends Chain, account extends SmartAccount | undefined>(\n  client: Client<Transport, chain, account>,\n) => Pick<BundlerActions<account>, \"sendUserOperation\"> {\n  return (client) => ({\n    async sendUserOperation(args) {\n      const _sendUserOperation = getAction(client, viem_sendUserOperation, \"sendUserOperation\");\n\n      if (args.callData) {\n        return _sendUserOperation(args as never); // TODO: fix type issue\n      }\n\n      const calls = await Promise.all(\n        args.calls.map(async (call) => {\n          // Skip if the call doesn't match the decoded format (`functionName`, `args`, `to`)\n          if (!isDecodedCall(call)) return call;\n\n          // Skip if the contract isn't the World or the function called should not be redirected through `callFrom`.\n          if (\n            call.to !== params.worldAddress ||\n            call.functionName === \"call\" ||\n            call.functionName === \"callFrom\" ||\n            call.functionName === \"batchCallFrom\" ||\n            call.functionName === \"callWithSignature\"\n          ) {\n            return call;\n          }\n\n          // Wrap system calls from `batchCall` with delegator for a `batchCallFrom`\n          // TODO: remove this specific workaround once https://github.com/latticexyz/mud/pull/3506 lands\n          if (call.functionName === \"batchCall\") {\n            const batchCallArgs = call.args as unknown as WriteContractParameters<worldCallAbi, \"batchCall\">;\n            const [systemCalls] = batchCallArgs.args;\n            if (!systemCalls.length) {\n              throw new Error(\"`batchCall` should have at least one system call.\");\n            }\n\n            return {\n              ...call,\n              functionName: \"batchCallFrom\",\n              args: [systemCalls.map((systemCall) => ({ from: params.delegatorAddress, ...systemCall }))],\n            };\n          }\n\n          // Encode the World's calldata (which includes the World's function selector).\n          const worldCalldata = encodeFunctionData({\n            abi: call.abi,\n            functionName: call.functionName,\n            args: call.args,\n          } as unknown as EncodeFunctionDataParameters);\n\n          // The first 4 bytes of calldata represent the function selector.\n          const worldFunctionSelector = slice(worldCalldata, 0, 4);\n\n          // Get the systemId and System's function selector.\n          const { systemId, systemFunctionSelector } = await worldFunctionToSystemFunction({\n            ...params,\n            publicClient: params.publicClient ?? client,\n            worldFunctionSelector,\n          });\n\n          // Construct the System's calldata by replacing the World's function selector with the System's.\n          // Use `readHex` instead of `slice` to prevent out-of-bounds errors with calldata that has no args.\n          const systemCalldata = concat([systemFunctionSelector, readHex(worldCalldata, 4)]);\n\n          return {\n            ...call,\n            functionName: \"callFrom\",\n            args: [params.delegatorAddress, systemId, systemCalldata],\n          };\n        }),\n      );\n\n      // Call `sendUserOperation` with the new args.\n      return _sendUserOperation({ ...args, calls } as never); // TODO: fix type issue\n    },\n  });\n}\n\n// Matching https://github.com/wevm/viem/blob/26e4bcafb3be976510b4d8170ef29bb69e014263/src/types/calls.ts#L6-L23 (not exported)\ntype DecodedCall = {\n  abi: Abi;\n  functionName: string;\n  args: unknown[];\n  to: Hex;\n};\n\nfunction isDecodedCall(call: unknown): call is DecodedCall {\n  return typeof call === \"object\" && call != null && \"functionName\" in call && \"args\" in call && \"to\" in call;\n}\n","import { World } from \"./output\";\n\nexport type DynamicResolution = {\n  // TODO: add systemAddress support\n  type: \"tableId\";\n  input: string;\n};\n\nexport type ValueWithType = {\n  value: string | number | Uint8Array;\n  type: string;\n};\n\n/**\n * Dynamically resolve a table name to a table id at deploy time\n */\nexport function resolveTableId(tableName: string) {\n  return {\n    type: \"tableId\",\n    input: tableName,\n  } as const;\n}\n\n/** Type guard for DynamicResolution */\nexport function isDynamicResolution(value: unknown): value is DynamicResolution {\n  return typeof value === \"object\" && value !== null && \"type\" in value && \"input\" in value;\n}\n\n/** Type guard for ValueWithType */\nexport function isValueWithType(value: unknown): value is ValueWithType {\n  return typeof value === \"object\" && value !== null && \"type\" in value && \"value\" in value;\n}\n\n/**\n * Turn a DynamicResolution object into a ValueWithType based on the provided context\n */\nexport function resolveWithContext(\n  input: unknown,\n  context: { config: World; systemAddresses?: Record<string, Promise<string>> },\n): ValueWithType {\n  if (isValueWithType(input)) return input;\n\n  if (isDynamicResolution(input)) {\n    if (input.type === \"tableId\") {\n      const tableEntries = Object.entries(context.config.tables).filter(\n        ([tableName, table]) => tableName === input.input || table.name === input.input,\n      );\n\n      if (tableEntries.length > 1) {\n        throw new Error(\n          `Found more than one table with name \"${input.input}\". Try using one of the following table names instead: ${tableEntries.map(([tableName]) => tableName).join(\", \")}`,\n        );\n      }\n\n      if (tableEntries.length === 1) {\n        const [entry] = tableEntries;\n        const [, table] = entry;\n        return { type: \"bytes32\", value: table.tableId };\n      }\n    }\n  }\n\n  throw new Error(`Could not resolve dynamic resolution:\\n${JSON.stringify(input, null, 2)}`);\n}\n"],"mappings":"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","names":["encodeFunctionData","encodeFunctionData","encodeFunctionData","encodeFunctionData","encodeFunctionData","encodeFunctionData","concat","getAction","encodeFunctionData","getAction","encodeFunctionData","concat","slice","concat","getAction","encodeFunctionData","readHex","getAction","encodeFunctionData","slice","concat","readHex"]}

package/dist/node.js

@@ -258,6 +258,7 @@ import {
   renderedSolidityHeader as renderedSolidityHeader2,
   renderImports as renderImports2
 } from "@latticexyz/common/codegen";
+import { stringToHex } from "viem";
 function renderSystemLibrary(options) {
   const {
     imports: systemImports,
@@ -273,6 +274,9 @@ function renderSystemLibrary(options) {
   } = options;
   const functions = functionsInput.map((func) => ({
     ...func,
+    // Format parameters (add auxiliary argument names, replace calldata location)
+    parameters: formatParams(func.parameters),
+    // Remove `payable` from stateMutability for library functions
     stateMutability: func.stateMutability.replace("payable", "")
   }));
   const imports = [
@@ -394,7 +398,7 @@ function renderErrors(errors) {
 }
 function renderUserTypeFunction(contractFunction, userTypeName) {
   const { name, parameters, stateMutability, returnParameters } = contractFunction;
-  const args = [`${userTypeName} self`, ...parameters].map((arg) => arg.replace(/ calldata /, " memory "));
+  const args = [`${userTypeName} self`, ...parameters];
   const functionSignature = `
     function ${name}(
       ${renderArguments2(args)}
@@ -411,7 +415,7 @@ function renderUserTypeFunction(contractFunction, userTypeName) {
 }
 function renderCallWrapperFunction(contractFunction, callingFromRootSystemErrorName) {
   const { name, parameters, stateMutability, returnParameters } = contractFunction;
-  const args = [`CallWrapper memory self`, ...parameters].map((arg) => arg.replace(/ calldata /, " memory "));
+  const args = [`CallWrapper memory self`, ...parameters];
   const functionSignature = `
     function ${name}(
       ${renderArguments2(args)}
@@ -455,7 +459,7 @@ function renderRootCallWrapperFunction(contractFunction, namespace) {
   if (namespace === "" && stateMutability != "") {
     return "";
   }
-  const args = ["RootCallWrapper memory self", ...parameters].map((arg) => arg.replace(/ calldata /, " memory "));
+  const args = ["RootCallWrapper memory self", ...parameters];
   const functionSignature = `
     function ${name}(
       ${renderArguments2(args)}
@@ -496,7 +500,7 @@ function renderFunctionInterface(contractFunction) {
 }
 function functionInterfaceName(contractFunction) {
   const { name, parameters } = contractFunction;
-  const paramTypes = parameters.map((param) => param.split(" ")[0]).map((type5) => type5.replace("[]", "Array")).join("_");
+  const paramTypes = parameters.map((param) => param.split(" ")[0]).map((type5) => type5.replace("[]", "Array")).map((type5) => type5.replace(/\[.+\]/, (match2) => stringToHex(match2))).join("_");
   return `_${name}${paramTypes.length === 0 ? "" : `_${paramTypes}`}`;
 }
 function renderEncodeSystemCall(contractFunction) {
@@ -516,6 +520,14 @@ function renderReturnParameters2(returnParameters) {
   if (returnParameters.length == 0) return "";
   return `returns (${renderArguments2(returnParameters)})`;
 }
+function formatParams(params) {
+  let auxCount = 0;
+  return params.map((arg) => arg.replace(/ calldata /, " memory ")).map((arg) => {
+    const items = arg.split(" ");
+    const needsAux = items.length === 1 || items.length === 2 && items[1] === "memory";
+    return needsAux ? `${arg} __aux${auxCount++}` : arg;
+  });
+}
 
 // ts/node/render-solidity/renderWorldInterface.ts
 import { renderArguments as renderArguments3, renderedSolidityHeader as renderedSolidityHeader3, renderImports as renderImports3 } from "@latticexyz/common/codegen";
@@ -557,7 +569,7 @@ function renderWorldInterface({
 }
 
 // ts/node/render-solidity/worldgen.ts
-import fs from "node:fs/promises";
+import fs2 from "node:fs/promises";
 import path4 from "node:path";
 import { formatAndWriteSolidity, contractToInterface } from "@latticexyz/common/codegen";
 
@@ -566,6 +578,7 @@ import { isHex } from "viem";
 
 // ts/node/getSystemContracts.ts
 import path3 from "node:path";
+import fs from "node:fs/promises";
 
 // ts/node/findSolidityFiles.ts
 import path2 from "node:path";
@@ -5274,8 +5287,8 @@ var PathScurryBase = class {
    *
    * @internal
    */
-  constructor(cwd = process.cwd(), pathImpl, sep2, { nocase, childrenCacheSize = 16 * 1024, fs: fs3 = defaultFS } = {}) {
-    this.#fs = fsFromOption(fs3);
+  constructor(cwd = process.cwd(), pathImpl, sep2, { nocase, childrenCacheSize = 16 * 1024, fs: fs4 = defaultFS } = {}) {
+    this.#fs = fsFromOption(fs4);
     if (cwd instanceof URL || cwd.startsWith("file://")) {
       cwd = fileURLToPath(cwd);
     }
@@ -5833,8 +5846,8 @@ var PathScurryWin32 = class extends PathScurryBase {
   /**
    * @internal
    */
-  newRoot(fs3) {
-    return new PathWin32(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs3 });
+  newRoot(fs4) {
+    return new PathWin32(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs4 });
   }
   /**
    * Return true if the provided path string is an absolute path
@@ -5862,8 +5875,8 @@ var PathScurryPosix = class extends PathScurryBase {
   /**
    * @internal
    */
-  newRoot(fs3) {
-    return new PathPosix(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs3 });
+  newRoot(fs4) {
+    return new PathPosix(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs4 });
   }
   /**
    * Return true if the provided path string is an absolute path
@@ -6951,19 +6964,25 @@ async function findSolidityFiles({ cwd, pattern = "**" }) {
 }
 
 // ts/node/getSystemContracts.ts
+import { parseSystem } from "@latticexyz/common/codegen";
+import { isDefined } from "@latticexyz/common/utils";
 async function getSystemContracts({
   rootDir,
   config
 }) {
-  const solidityFiles = await findSolidityFiles({
+  const filePaths = await findSolidityFiles({
     cwd: rootDir,
     pattern: path3.join(config.sourceDirectory, "**")
   });
-  return solidityFiles.filter(
-    (file) => file.basename.endsWith("System") && // exclude the base System contract
-    file.basename !== "System" && // exclude interfaces
-    !/^I[A-Z]/.test(file.basename)
-  ).map((file) => {
+  const files = await Promise.all(
+    filePaths.map(async (file) => {
+      const source = await fs.readFile(path3.join(rootDir, file.filename), "utf-8");
+      return { ...file, source };
+    })
+  );
+  return files.map((file) => {
+    const parsedSystem = parseSystem(file.source, file.basename);
+    if (!parsedSystem) return;
     const namespaceLabel = (() => {
       if (!config.multipleNamespaces && config.namespace != null) return config.namespace;
       const relativePath = path3.relative(path3.join(rootDir, config.sourceDirectory), file.filename);
@@ -6980,7 +6999,7 @@ async function getSystemContracts({
       namespaceLabel,
       systemLabel: file.basename
     };
-  });
+  }).filter(isDefined);
 }
 
 // ts/node/resolveSystems.ts
@@ -7038,7 +7057,7 @@ async function worldgen({
     config.codegen.outputDirectory,
     config.codegen.worldgenDirectory
   );
-  const systems = (await resolveSystems({ rootDir, config })).filter((system) => system.deploy.registerWorldFunctions).map((system) => {
+  const systems = (await resolveSystems({ rootDir, config })).filter((system) => system.deploy.registerWorldFunctions || config.codegen.generateSystemLibraries).map((system) => {
     const interfaceName = `I${system.label}`;
     const libraryName = `${system.label}Lib`;
     const sourceDir = config.multipleNamespaces ? path4.join(config.sourceDirectory, "namespaces", system.namespaceLabel) : config.sourceDirectory;
@@ -7058,12 +7077,12 @@ async function worldgen({
   if (clean) {
     const libraryDirs = [...new Set(systems.map(({ libraryPath }) => path4.dirname(libraryPath)))];
     await Promise.all([
-      fs.rm(worldgenOutDir, { recursive: true, force: true }),
-      ...libraryDirs.map((dir) => fs.rm(dir, { recursive: true, force: true }))
+      fs2.rm(worldgenOutDir, { recursive: true, force: true }),
+      ...libraryDirs.map((dir) => fs2.rm(dir, { recursive: true, force: true }))
     ]);
   }
   const outputPath = path4.join(worldgenOutDir, config.codegen.worldInterfaceName + ".sol");
-  const worldImports = systems.map(
+  const worldImports = systems.filter((system) => system.deploy.registerWorldFunctions).map(
     (system) => ({
       symbol: system.interfaceName,
       path: "./" + path4.relative(path4.dirname(outputPath), system.interfacePath)
@@ -7073,22 +7092,24 @@ async function worldgen({
   const worldImportPath = config.codegen.worldImportPath.startsWith(".") ? "./" + path4.relative(path4.dirname(outputPath), path4.join(rootDir, config.codegen.worldImportPath)) : config.codegen.worldImportPath;
   await Promise.all(
     systems.map(async (system) => {
-      const source = await fs.readFile(path4.join(rootDir, system.sourcePath), "utf8");
+      const source = await fs2.readFile(path4.join(rootDir, system.sourcePath), "utf8");
       const { functions, errors, symbolImports } = contractToInterface(source, system.label);
-      const interfaceImports = symbolImports.map(
-        ({ symbol, path: importPath }) => ({
-          symbol,
-          path: importPath.startsWith(".") ? "./" + path4.relative(worldgenOutDir, path4.join(rootDir, path4.dirname(system.sourcePath), importPath)) : importPath
-        })
-      );
-      const systemInterface = renderSystemInterface({
-        name: system.interfaceName,
-        functionPrefix: system.namespace === "" ? "" : `${system.namespace}__`,
-        functions,
-        errors,
-        imports: interfaceImports
-      });
-      await formatAndWriteSolidity(systemInterface, system.interfacePath, "Generated system interface");
+      if (system.deploy.registerWorldFunctions) {
+        const interfaceImports = symbolImports.map(
+          ({ symbol, path: importPath }) => ({
+            symbol,
+            path: importPath.startsWith(".") ? "./" + path4.relative(worldgenOutDir, path4.join(rootDir, path4.dirname(system.sourcePath), importPath)) : importPath
+          })
+        );
+        const systemInterface = renderSystemInterface({
+          name: system.interfaceName,
+          functionPrefix: system.namespace === "" ? "" : `${system.namespace}__`,
+          functions,
+          errors,
+          imports: interfaceImports
+        });
+        await formatAndWriteSolidity(systemInterface, system.interfacePath, "Generated system interface");
+      }
       if (config.codegen.generateSystemLibraries) {
         const systemImport = {
           symbol: system.label,
@@ -7133,7 +7154,7 @@ async function worldgen({
 import path5 from "node:path";
 import { readFile } from "node:fs/promises";
 import { type as type2 } from "arktype";
-import { indent, isDefined } from "@latticexyz/common/utils";
+import { indent, isDefined as isDefined2 } from "@latticexyz/common/utils";
 import { size, sliceHex } from "viem";
 
 // ts/node/common.ts
@@ -7211,7 +7232,7 @@ ${indent(artifact.message)}`);
       return;
     }
     return artifact;
-  }).filter(isDefined).filter(hasMetadata).map((artifact) => {
+  }).filter(isDefined2).filter(hasMetadata).map((artifact) => {
     artifact;
     const sourcePath = Object.keys(artifact.metadata.settings.compilationTarget)[0];
     const name = artifact.metadata.settings.compilationTarget[sourcePath];
@@ -7320,7 +7341,7 @@ async function buildSystemsManifest(opts) {
 }
 
 // ts/node/loadSystemsManifest.ts
-import fs2 from "node:fs/promises";
+import fs3 from "node:fs/promises";
 import path7 from "node:path";
 import { type as type4 } from "arktype";
 import { indent as indent2 } from "@latticexyz/common/utils";
@@ -7328,13 +7349,13 @@ var parseManifest = type4("string").pipe.try((s) => JSON.parse(s), SystemsManife
 async function loadSystemsManifest(opts) {
   const outFile = path7.join(opts.rootDir, systemsManifestFilename);
   try {
-    await fs2.access(outFile, fs2.constants.F_OK | fs2.constants.R_OK);
+    await fs3.access(outFile, fs3.constants.F_OK | fs3.constants.R_OK);
   } catch (error2) {
     throw new Error(
       `Systems manifest at "${systemsManifestFilename}" not found or not readable. Run \`mud build\` before trying again.`
     );
   }
-  const json = await fs2.readFile(outFile, "utf8");
+  const json = await fs3.readFile(outFile, "utf8");
   const manifest = parseManifest(json);
   if (manifest instanceof type4.errors) {
     throw new Error(