@latticexyz/world-module-callwithsignature 2.2.17-03eae1330cef5cae129841958fb75541ef13fb43

package/src/ICallWithSignatureErrors.sol

@@ -0,0 +1,9 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.24;
+
+interface ICallWithSignatureErrors {
+  /**
+   * @dev Mismatched signature.
+   */
+  error InvalidSignature();
+}

package/src/IERC1271.sol

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC1271.sol)
+
+pragma solidity ^0.8.24;
+
+/**
+ * @dev Interface of the ERC-1271 standard signature validation method for
+ * contracts as defined in https://eips.ethereum.org/EIPS/eip-1271[ERC-1271].
+ */
+interface IERC1271 {
+  /**
+   * @dev Should return whether the signature provided is valid for the provided data
+   * @param hash      Hash of the data to be signed
+   * @param signature Signature byte array associated with _data
+   */
+  function isValidSignature(bytes32 hash, bytes memory signature) external view returns (bytes4 magicValue);
+}

package/src/SignatureChecker.sol

@@ -0,0 +1,50 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts (last updated v5.0.0) (utils/cryptography/SignatureChecker.sol)
+
+pragma solidity ^0.8.24;
+
+import { ECDSA } from "./ECDSA.sol";
+import { IERC1271 } from "./IERC1271.sol";
+
+/**
+ * @dev Signature verification helper that can be used instead of `ECDSA.recover` to seamlessly support both ECDSA
+ * signatures from externally owned accounts (EOAs) as well as ERC-1271 signatures from smart contract wallets like
+ * Argent and Safe Wallet (previously Gnosis Safe).
+ */
+library SignatureChecker {
+  /**
+   * @dev Checks if a signature is valid for a given signer and data hash. If the signer is a smart contract, the
+   * signature is validated against that smart contract using ERC-1271, otherwise it's validated using `ECDSA.recover`.
+   *
+   * NOTE: Unlike ECDSA signatures, contract signatures are revocable, and the outcome of this function can thus
+   * change through time. It could return true at block N and false at block N+1 (or the opposite).
+   */
+  function isValidSignatureNow(address signer, bytes32 hash, bytes memory signature) internal view returns (bool) {
+    if (signer.code.length == 0) {
+      (address recovered, ECDSA.RecoverError err, ) = ECDSA.tryRecover(hash, signature);
+      return err == ECDSA.RecoverError.NoError && recovered == signer;
+    } else {
+      return isValidERC1271SignatureNow(signer, hash, signature);
+    }
+  }
+
+  /**
+   * @dev Checks if a signature is valid for a given signer and data hash. The signature is validated
+   * against the signer smart contract using ERC-1271.
+   *
+   * NOTE: Unlike ECDSA signatures, contract signatures are revocable, and the outcome of this function can thus
+   * change through time. It could return true at block N and false at block N+1 (or the opposite).
+   */
+  function isValidERC1271SignatureNow(
+    address signer,
+    bytes32 hash,
+    bytes memory signature
+  ) internal view returns (bool) {
+    (bool success, bytes memory result) = signer.staticcall(
+      abi.encodeCall(IERC1271.isValidSignature, (hash, signature))
+    );
+    return (success &&
+      result.length >= 32 &&
+      abi.decode(result, (bytes32)) == bytes32(IERC1271.isValidSignature.selector));
+  }
+}

package/src/codegen/index.sol

@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.24;
+
+/* Autogenerated file. Do not edit manually. */
+
+import { CallWithSignatureNonces } from "./tables/CallWithSignatureNonces.sol";

package/src/codegen/tables/CallWithSignatureNonces.sol

@@ -0,0 +1,199 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.24;
+
+/* Autogenerated file. Do not edit manually. */
+
+// Import store internals
+import { IStore } from "@latticexyz/store/src/IStore.sol";
+import { StoreSwitch } from "@latticexyz/store/src/StoreSwitch.sol";
+import { StoreCore } from "@latticexyz/store/src/StoreCore.sol";
+import { Bytes } from "@latticexyz/store/src/Bytes.sol";
+import { Memory } from "@latticexyz/store/src/Memory.sol";
+import { SliceLib } from "@latticexyz/store/src/Slice.sol";
+import { EncodeArray } from "@latticexyz/store/src/tightcoder/EncodeArray.sol";
+import { FieldLayout } from "@latticexyz/store/src/FieldLayout.sol";
+import { Schema } from "@latticexyz/store/src/Schema.sol";
+import { EncodedLengths, EncodedLengthsLib } from "@latticexyz/store/src/EncodedLengths.sol";
+import { ResourceId } from "@latticexyz/store/src/ResourceId.sol";
+
+library CallWithSignatureNonces {
+  // Hex below is the result of `WorldResourceIdLib.encode({ namespace: "", name: "CallWithSignatur", typeId: RESOURCE_TABLE });`
+  ResourceId constant _tableId = ResourceId.wrap(0x7462000000000000000000000000000043616c6c576974685369676e61747572);
+
+  FieldLayout constant _fieldLayout =
+    FieldLayout.wrap(0x0020010020000000000000000000000000000000000000000000000000000000);
+
+  // Hex-encoded key schema of (address)
+  Schema constant _keySchema = Schema.wrap(0x0014010061000000000000000000000000000000000000000000000000000000);
+  // Hex-encoded value schema of (uint256)
+  Schema constant _valueSchema = Schema.wrap(0x002001001f000000000000000000000000000000000000000000000000000000);
+
+  /**
+   * @notice Get the table's key field names.
+   * @return keyNames An array of strings with the names of key fields.
+   */
+  function getKeyNames() internal pure returns (string[] memory keyNames) {
+    keyNames = new string[](1);
+    keyNames[0] = "signer";
+  }
+
+  /**
+   * @notice Get the table's value field names.
+   * @return fieldNames An array of strings with the names of value fields.
+   */
+  function getFieldNames() internal pure returns (string[] memory fieldNames) {
+    fieldNames = new string[](1);
+    fieldNames[0] = "nonce";
+  }
+
+  /**
+   * @notice Register the table with its config.
+   */
+  function register() internal {
+    StoreSwitch.registerTable(_tableId, _fieldLayout, _keySchema, _valueSchema, getKeyNames(), getFieldNames());
+  }
+
+  /**
+   * @notice Register the table with its config.
+   */
+  function _register() internal {
+    StoreCore.registerTable(_tableId, _fieldLayout, _keySchema, _valueSchema, getKeyNames(), getFieldNames());
+  }
+
+  /**
+   * @notice Get nonce.
+   */
+  function getNonce(address signer) internal view returns (uint256 nonce) {
+    bytes32[] memory _keyTuple = new bytes32[](1);
+    _keyTuple[0] = bytes32(uint256(uint160(signer)));
+
+    bytes32 _blob = StoreSwitch.getStaticField(_tableId, _keyTuple, 0, _fieldLayout);
+    return (uint256(bytes32(_blob)));
+  }
+
+  /**
+   * @notice Get nonce.
+   */
+  function _getNonce(address signer) internal view returns (uint256 nonce) {
+    bytes32[] memory _keyTuple = new bytes32[](1);
+    _keyTuple[0] = bytes32(uint256(uint160(signer)));
+
+    bytes32 _blob = StoreCore.getStaticField(_tableId, _keyTuple, 0, _fieldLayout);
+    return (uint256(bytes32(_blob)));
+  }
+
+  /**
+   * @notice Get nonce.
+   */
+  function get(address signer) internal view returns (uint256 nonce) {
+    bytes32[] memory _keyTuple = new bytes32[](1);
+    _keyTuple[0] = bytes32(uint256(uint160(signer)));
+
+    bytes32 _blob = StoreSwitch.getStaticField(_tableId, _keyTuple, 0, _fieldLayout);
+    return (uint256(bytes32(_blob)));
+  }
+
+  /**
+   * @notice Get nonce.
+   */
+  function _get(address signer) internal view returns (uint256 nonce) {
+    bytes32[] memory _keyTuple = new bytes32[](1);
+    _keyTuple[0] = bytes32(uint256(uint160(signer)));
+
+    bytes32 _blob = StoreCore.getStaticField(_tableId, _keyTuple, 0, _fieldLayout);
+    return (uint256(bytes32(_blob)));
+  }
+
+  /**
+   * @notice Set nonce.
+   */
+  function setNonce(address signer, uint256 nonce) internal {
+    bytes32[] memory _keyTuple = new bytes32[](1);
+    _keyTuple[0] = bytes32(uint256(uint160(signer)));
+
+    StoreSwitch.setStaticField(_tableId, _keyTuple, 0, abi.encodePacked((nonce)), _fieldLayout);
+  }
+
+  /**
+   * @notice Set nonce.
+   */
+  function _setNonce(address signer, uint256 nonce) internal {
+    bytes32[] memory _keyTuple = new bytes32[](1);
+    _keyTuple[0] = bytes32(uint256(uint160(signer)));
+
+    StoreCore.setStaticField(_tableId, _keyTuple, 0, abi.encodePacked((nonce)), _fieldLayout);
+  }
+
+  /**
+   * @notice Set nonce.
+   */
+  function set(address signer, uint256 nonce) internal {
+    bytes32[] memory _keyTuple = new bytes32[](1);
+    _keyTuple[0] = bytes32(uint256(uint160(signer)));
+
+    StoreSwitch.setStaticField(_tableId, _keyTuple, 0, abi.encodePacked((nonce)), _fieldLayout);
+  }
+
+  /**
+   * @notice Set nonce.
+   */
+  function _set(address signer, uint256 nonce) internal {
+    bytes32[] memory _keyTuple = new bytes32[](1);
+    _keyTuple[0] = bytes32(uint256(uint160(signer)));
+
+    StoreCore.setStaticField(_tableId, _keyTuple, 0, abi.encodePacked((nonce)), _fieldLayout);
+  }
+
+  /**
+   * @notice Delete all data for given keys.
+   */
+  function deleteRecord(address signer) internal {
+    bytes32[] memory _keyTuple = new bytes32[](1);
+    _keyTuple[0] = bytes32(uint256(uint160(signer)));
+
+    StoreSwitch.deleteRecord(_tableId, _keyTuple);
+  }
+
+  /**
+   * @notice Delete all data for given keys.
+   */
+  function _deleteRecord(address signer) internal {
+    bytes32[] memory _keyTuple = new bytes32[](1);
+    _keyTuple[0] = bytes32(uint256(uint160(signer)));
+
+    StoreCore.deleteRecord(_tableId, _keyTuple, _fieldLayout);
+  }
+
+  /**
+   * @notice Tightly pack static (fixed length) data using this table's schema.
+   * @return The static data, encoded into a sequence of bytes.
+   */
+  function encodeStatic(uint256 nonce) internal pure returns (bytes memory) {
+    return abi.encodePacked(nonce);
+  }
+
+  /**
+   * @notice Encode all of a record's fields.
+   * @return The static (fixed length) data, encoded into a sequence of bytes.
+   * @return The lengths of the dynamic fields (packed into a single bytes32 value).
+   * @return The dynamic (variable length) data, encoded into a sequence of bytes.
+   */
+  function encode(uint256 nonce) internal pure returns (bytes memory, EncodedLengths, bytes memory) {
+    bytes memory _staticData = encodeStatic(nonce);
+
+    EncodedLengths _encodedLengths;
+    bytes memory _dynamicData;
+
+    return (_staticData, _encodedLengths, _dynamicData);
+  }
+
+  /**
+   * @notice Encode keys as a bytes32 array using this table's field layout.
+   */
+  function encodeKeyTuple(address signer) internal pure returns (bytes32[] memory) {
+    bytes32[] memory _keyTuple = new bytes32[](1);
+    _keyTuple[0] = bytes32(uint256(uint160(signer)));
+
+    return _keyTuple;
+  }
+}

package/src/codegen/world/ICallWithSignatureSystem.sol

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.24;
+
+/* Autogenerated file. Do not edit manually. */
+
+import { ResourceId } from "@latticexyz/store/src/ResourceId.sol";
+
+/**
+ * @title ICallWithSignatureSystem
+ * @author MUD (https://mud.dev) by Lattice (https://lattice.xyz)
+ * @dev This interface is automatically generated from the corresponding system contract. Do not edit manually.
+ */
+interface ICallWithSignatureSystem {
+  function callWithSignature(
+    address signer,
+    ResourceId systemId,
+    bytes memory callData,
+    bytes memory signature
+  ) external payable returns (bytes memory);
+}

package/src/codegen/world/IWorld.sol

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.24;
+
+/* Autogenerated file. Do not edit manually. */
+
+import { IBaseWorld } from "@latticexyz/world/src/codegen/interfaces/IBaseWorld.sol";
+import { ICallWithSignatureSystem } from "./ICallWithSignatureSystem.sol";
+
+/**
+ * @title IWorld
+ * @author MUD (https://mud.dev) by Lattice (https://lattice.xyz)
+ * @notice This interface integrates all systems and associated function selectors
+ * that are dynamically registered in the World during deployment.
+ * @dev This is an autogenerated file; do not edit manually.
+ */
+interface IWorld is IBaseWorld, ICallWithSignatureSystem {}

package/src/constants.sol

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.24;
+
+import { ResourceId } from "@latticexyz/world/src/WorldResourceId.sol";
+import { ROOT_NAMESPACE } from "@latticexyz/world/src/constants.sol";
+import { RESOURCE_TABLE, RESOURCE_SYSTEM, RESOURCE_NAMESPACE } from "@latticexyz/world/src/worldResourceTypes.sol";
+
+ResourceId constant DELEGATION_SYSTEM_ID = ResourceId.wrap(
+  (bytes32(abi.encodePacked(RESOURCE_SYSTEM, ROOT_NAMESPACE, "Delegation")))
+);

package/src/getSignedMessageHash.sol

@@ -0,0 +1,54 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.24;
+
+import { ResourceId } from "@latticexyz/store/src/ResourceId.sol";
+import { WorldResourceIdLib, WorldResourceIdInstance } from "@latticexyz/world/src/WorldResourceId.sol";
+
+using WorldResourceIdInstance for ResourceId;
+
+// Note the intended value of the `salt` field is the chain ID.
+// It is not included in `chainId`, to allow cross-chain signing without requiring wallets to switch networks.
+// The value of this field should be the chain on which the world lives, rather than the chain the wallet is connected to.
+bytes32 constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(address verifyingContract,bytes32 salt)");
+bytes32 constant CALL_TYPEHASH = keccak256(
+  "Call(address signer,string systemNamespace,string systemName,bytes callData,uint256 nonce)"
+);
+
+/**
+ * @notice Generate the message hash for a given delegation signature.
+ * For EIP712 signatures https://eips.ethereum.org/EIPS/eip-712
+ * @dev We include the signer address to prevent generating a signature that recovers to a random address that didn't sign the message.
+ * @param signer The address on whose behalf the system is called.
+ * @param systemId The ID of the system to be called.
+ * @param callData The ABI data for the system call.
+ * @param nonce The nonce of the signer
+ * @param worldAddress The world address
+ * @return Return the message hash.
+ */
+function getSignedMessageHash(
+  address signer,
+  ResourceId systemId,
+  bytes memory callData,
+  uint256 nonce,
+  address worldAddress
+) view returns (bytes32) {
+  bytes32 domainSeperator = keccak256(abi.encode(DOMAIN_TYPEHASH, worldAddress, bytes32(block.chainid)));
+
+  return
+    keccak256(
+      abi.encodePacked(
+        "\x19\x01",
+        domainSeperator,
+        keccak256(
+          abi.encode(
+            CALL_TYPEHASH,
+            signer,
+            keccak256(abi.encodePacked(WorldResourceIdLib.toTrimmedString(systemId.getNamespace()))),
+            keccak256(abi.encodePacked(WorldResourceIdLib.toTrimmedString(systemId.getName()))),
+            keccak256(callData),
+            nonce
+          )
+        )
+      )
+    );
+}

package/src/validateCallWithSignature.sol

@@ -0,0 +1,31 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.24;
+import { ResourceId } from "@latticexyz/world/src/WorldResourceId.sol";
+import { WorldContextConsumerLib } from "@latticexyz/world/src/WorldContext.sol";
+import { CallWithSignatureNonces } from "./codegen/tables/CallWithSignatureNonces.sol";
+import { getSignedMessageHash } from "./getSignedMessageHash.sol";
+import { ECDSA } from "./ECDSA.sol";
+import { ICallWithSignatureErrors } from "./ICallWithSignatureErrors.sol";
+import { SignatureChecker } from "./SignatureChecker.sol";
+
+/**
+ * @notice Verifies the given system call corresponds to the given signature.
+ * @param signer The address on whose behalf the system is called.
+ * @param systemId The ID of the system to be called.
+ * @param callData The ABI data for the system call.
+ * @param signature The EIP712 signature.
+ * @dev Reverts with InvalidSignature(recoveredSigner) if the signature is invalid.
+ */
+function validateCallWithSignature(
+  address signer,
+  ResourceId systemId,
+  bytes memory callData,
+  bytes memory signature
+) view {
+  uint256 nonce = CallWithSignatureNonces._get(signer);
+  bytes32 hash = getSignedMessageHash(signer, systemId, callData, nonce, WorldContextConsumerLib._world());
+
+  if (!SignatureChecker.isValidSignatureNow(signer, hash, signature)) {
+    revert ICallWithSignatureErrors.InvalidSignature();
+  }
+}