@latticexyz/world 1.40.0 → 1.41.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@latticexyz/world",
   "license": "MIT",
-  "version": "1.40.0",
+  "version": "1.41.0",
   "description": "World framework",
   "types": "./types/ethers-contracts/",
   "repository": {
@@ -22,20 +22,20 @@
     "lint": "yarn prettier && yarn solhint",
     "link": "yarn link",
     "docs": "rimraf API && hardhat docgen && echo 'label: API\norder: 50' > API/index.yml",
-    "release": "npm publish || echo 'version already published'",
+    "release": "npm publish --access=public",
     "gas-report": "mud gas-report --path test/** --save gas-report.txt"
   },
   "devDependencies": {
-    "@latticexyz/cli": "^1.40.0",
-    "@latticexyz/schema-type": "^1.40.0",
-    "@latticexyz/store": "^1.40.0",
+    "@latticexyz/cli": "^1.41.0",
+    "@latticexyz/schema-type": "^1.41.0",
+    "@latticexyz/store": "^1.41.0",
     "@typechain/ethers-v5": "^9.0.0",
     "@types/mocha": "^9.1.1",
     "ds-test": "https://github.com/dapphub/ds-test.git#c9ce3f25bde29fc5eb9901842bf02850dfd2d084",
     "forge-std": "https://github.com/foundry-rs/forge-std.git#f36dab24d63d1c1945a05ed375ce341d3c1a49ed",
     "hardhat": "^2.10.1",
-    "prettier": "^2.6.2",
-    "prettier-plugin-solidity": "^1.0.0-beta.19",
+    "prettier": "^2.8.4",
+    "prettier-plugin-solidity": "^1.1.2",
     "rimraf": "^3.0.2",
     "solhint": "^3.3.7",
     "solidity-docgen": "^0.6.0-beta.22",
@@ -48,5 +48,5 @@
     "ds-test": "https://github.com/dapphub/ds-test.git#c9ce3f25bde29fc5eb9901842bf02850dfd2d084",
     "forge-std": "https://github.com/foundry-rs/forge-std.git#f36dab24d63d1c1945a05ed375ce341d3c1a49ed"
   },
-  "gitHead": "914a1e0ae4a573d685841ca2ea921435057deb8f"
+  "gitHead": "ecac84146f0288e3a129d1d3dbfaf373db86b1ab"
 }

package/src/World.sol

@@ -45,7 +45,7 @@ contract World is Store {
   /**
    * Register a new route by extending an existing route
    */
-  function registerRoute(string calldata baseRoute, string calldata subRoute) public returns (uint256 routeId) {
+  function registerRoute(string calldata baseRoute, string calldata subRoute) public virtual returns (uint256 routeId) {
     // Require subroute to be a valid route fragment (start with `/` and don't contain any further `/`)
     if (!_isSingleLevelRoute(subRoute)) revert RouteInvalid(subRoute);
 
@@ -53,6 +53,9 @@ contract World is Store {
     uint256 baseRouteId = _toRouteId(baseRoute);
     if (!(baseRouteId == ROOT_ROUTE_ID || RouteTable.has(baseRouteId))) revert RouteInvalid(baseRoute);
 
+    // Require subRoute to not be empty
+    if (bytes(subRoute).length == 0) revert RouteInvalid(subRoute);
+
     // Construct the new route
     string memory route = string(abi.encodePacked(baseRoute, subRoute));
     routeId = _toRouteId(route);
@@ -77,7 +80,7 @@ contract World is Store {
     string calldata baseRoute,
     string calldata tableRoute,
     Schema schema
-  ) public returns (uint256 tableRouteId) {
+  ) public virtual returns (uint256 tableRouteId) {
     // Register table route
     tableRouteId = uint256(registerRoute(baseRoute, tableRoute));
 
@@ -90,7 +93,7 @@ contract World is Store {
    * This overload exists to conform to the Store interface,
    * but it requires the caller to register a route using `registerRoute` first
    */
-  function registerSchema(uint256 tableId, Schema schema) public override {
+  function registerSchema(uint256 tableId, Schema schema) public virtual override {
     // Require caller to own the given tableId
     if (RouteOwnerTable.get(tableId) != msg.sender) revert RouteAccessDenied(RouteTable.get(tableId), msg.sender);
 
@@ -105,18 +108,14 @@ contract World is Store {
     string calldata tableRoute,
     string calldata tableName,
     string[] calldata fieldNames
-  ) public {
+  ) public virtual {
     setMetadata(_toRouteId(tableRoute), tableName, fieldNames);
   }
 
   /**
    * Register metadata (tableName, fieldNames) for a given table via its id
    */
-  function setMetadata(
-    uint256 tableId,
-    string calldata tableName,
-    string[] calldata fieldNames
-  ) public {
+  function setMetadata(uint256 tableId, string calldata tableName, string[] calldata fieldNames) public virtual {
     // Require caller to own the given tableId
     if (RouteOwnerTable.get(tableId) != msg.sender) revert RouteAccessDenied(RouteTable.get(tableId), msg.sender);
 
@@ -127,7 +126,7 @@ contract World is Store {
   /**
    * Register a hook for a given table route
    */
-  function registerTableHook(string calldata tableRoute, IStoreHook hook) public {
+  function registerTableHook(string calldata tableRoute, IStoreHook hook) public virtual {
     registerStoreHook(_toRouteId(tableRoute), hook);
   }
 
@@ -135,7 +134,7 @@ contract World is Store {
    * Register a hook for a given table route id
    * This overload exists to conform with the `IStore` interface.
    */
-  function registerStoreHook(uint256 tableId, IStoreHook hook) public override {
+  function registerStoreHook(uint256 tableId, IStoreHook hook) public virtual override {
     // Require caller to own the given tableId
     if (RouteOwnerTable.get(tableId) != msg.sender) revert RouteAccessDenied(RouteTable.get(tableId), msg.sender);
 
@@ -146,7 +145,7 @@ contract World is Store {
   /**
    * Register a hook for a given system route
    */
-  function registerSystemHook(string calldata systemRoute, ISystemHook hook) public {
+  function registerSystemHook(string calldata systemRoute, ISystemHook hook) public virtual {
     // TODO implement (see https://github.com/latticexyz/mud/issues/444)
   }
 
@@ -158,7 +157,7 @@ contract World is Store {
     string calldata systemRoute,
     System system,
     bool publicAccess
-  ) public returns (uint256 systemRouteId) {
+  ) public virtual returns (uint256 systemRouteId) {
     // Require the system to not exist yet
     if (SystemRouteTable.has(address(system))) revert SystemExists(address(system));
 
@@ -182,7 +181,7 @@ contract World is Store {
   /**
    * Grant access to a given route
    */
-  function grantAccess(string calldata route, address grantee) public {
+  function grantAccess(string calldata route, address grantee) public virtual {
     // Require the caller to own the route
     uint256 routeId = _toRouteId(route);
     if (RouteOwnerTable.get(routeId) != msg.sender) revert RouteAccessDenied(route, msg.sender);
@@ -194,7 +193,7 @@ contract World is Store {
   /**
    * Retract access to a given route
    */
-  function retractAccess(string calldata route, address grantee) public {
+  function retractAccess(string calldata route, address grantee) public virtual {
     // Require the caller to own the route
     uint256 routeId = _toRouteId(route);
     if (RouteOwnerTable.get(routeId) != msg.sender) revert RouteAccessDenied(route, msg.sender);
@@ -219,7 +218,7 @@ contract World is Store {
     string calldata subRoute,
     bytes32[] calldata key,
     bytes calldata data
-  ) public {
+  ) public virtual {
     // Require access to accessRoute
     if (!_hasAccess(accessRoute, msg.sender)) revert RouteAccessDenied(accessRoute, msg.sender);
 
@@ -237,11 +236,7 @@ contract World is Store {
    * Write a record in a table based on access right to the table route id.
    * This overload exists to conform with the `IStore` interface.
    */
-  function setRecord(
-    uint256 tableRouteId,
-    bytes32[] calldata key,
-    bytes calldata data
-  ) public {
+  function setRecord(uint256 tableRouteId, bytes32[] calldata key, bytes calldata data) public virtual {
     // Check access based on the tableRoute
     if (!_hasAccess(tableRouteId, msg.sender)) revert RouteAccessDenied(RouteTable.get(tableRouteId), msg.sender);
 
@@ -260,7 +255,7 @@ contract World is Store {
     bytes32[] calldata key,
     uint8 schemaIndex,
     bytes calldata data
-  ) public {
+  ) public virtual {
     // Require access to accessRoute
     if (!_hasAccess(accessRoute, msg.sender)) revert RouteAccessDenied(accessRoute, msg.sender);
 
@@ -283,7 +278,7 @@ contract World is Store {
     bytes32[] calldata key,
     uint8 schemaIndex,
     bytes calldata data
-  ) public override {
+  ) public virtual override {
     // Check access based on the tableRoute
     if (!_hasAccess(tableRouteId, msg.sender)) revert RouteAccessDenied(RouteTable.get(tableRouteId), msg.sender);
 
@@ -292,15 +287,47 @@ contract World is Store {
   }
 
   /**
-   * Delete a record in a table based on a parent route access right.
+   * Push data to the end of a field in a table based on a parent route access right.
    * We check for access based on `accessRoute`, and write to `accessRoute/subRoute`
    * because access to a route also grants access to all sub routes.
    */
-  function deleteRecord(
+  function pushToField(
     string calldata accessRoute,
     string calldata subRoute,
-    bytes32[] calldata key
+    bytes32[] calldata key,
+    uint8 schemaIndex,
+    bytes calldata dataToPush
   ) public {
+    // Check access based on accessRoute
+    uint256 tableRouteId = _verifiedTableRouteId(accessRoute, subRoute);
+
+    // Push to the field
+    StoreCore.pushToField(tableRouteId, key, schemaIndex, dataToPush);
+  }
+
+  /**
+   * Push data to the end of a field in a table based on specific access rights.
+   * This overload exists to conform with the `IStore` interface.
+   */
+  function pushToField(
+    uint256 tableRouteId,
+    bytes32[] calldata key,
+    uint8 schemaIndex,
+    bytes calldata dataToPush
+  ) public override {
+    // Check access based on the tableRoute
+    if (!_hasAccess(tableRouteId, msg.sender)) revert RouteAccessDenied(RouteTable.get(tableRouteId), msg.sender);
+
+    // Push to the field
+    StoreCore.pushToField(tableRouteId, key, schemaIndex, dataToPush);
+  }
+
+  /**
+   * Delete a record in a table based on a parent route access right.
+   * We check for access based on `accessRoute`, and write to `accessRoute/subRoute`
+   * because access to a route also grants access to all sub routes.
+   */
+  function deleteRecord(string calldata accessRoute, string calldata subRoute, bytes32[] calldata key) public virtual {
     // Require access to accessRoute
     if (!_hasAccess(accessRoute, msg.sender)) revert RouteAccessDenied(accessRoute, msg.sender);
 
@@ -318,7 +345,7 @@ contract World is Store {
    * Delete a record in a table based on specific access rights.
    * This overload exists to conform with the `IStore` interface.
    */
-  function deleteRecord(uint256 tableRouteId, bytes32[] calldata key) public override {
+  function deleteRecord(uint256 tableRouteId, bytes32[] calldata key) public virtual override {
     // Check access based on the tableRoute
     if (!_hasAccess(tableRouteId, msg.sender)) revert RouteAccessDenied(RouteTable.get(tableRouteId), msg.sender);
 
@@ -326,6 +353,25 @@ contract World is Store {
     StoreCore.deleteRecord(tableRouteId, key);
   }
 
+  /**
+   * Check for access based on `accessRoute`
+   * and return `tableRouteId` for `accessRoute/subRoute`
+   * because access to a route also grants access to all sub routes.
+   */
+  function _verifiedTableRouteId(
+    string calldata accessRoute,
+    string calldata subRoute
+  ) internal view returns (uint256 tableRouteId) {
+    // Require access to accessRoute
+    if (!_hasAccess(accessRoute, msg.sender)) revert RouteAccessDenied(accessRoute, msg.sender);
+
+    // Require a valid subRoute
+    if (!_isRoute(subRoute)) revert RouteInvalid(subRoute);
+
+    // Construct the table route id by concatenating accessRoute and tableRoute
+    tableRouteId = uint256(keccak256(abi.encodePacked(accessRoute, subRoute)));
+  }
+
   /************************************************************************
    *
    *    SYSTEM CALLS
@@ -341,13 +387,13 @@ contract World is Store {
     string calldata accessRoute,
     string memory subRoute,
     bytes calldata funcSelectorAndArgs
-  ) public returns (bytes memory) {
-    // Check if the system is a public system and get its address
+  ) public virtual returns (bytes memory) {
+    // Check if the system is a public virtual system and get its address
     string memory systemRoute = string(abi.encodePacked(accessRoute, subRoute));
     uint256 systemRouteId = _toRouteId(systemRoute);
     (address systemAddress, bool publicAccess) = SystemTable.get(systemRouteId);
 
-    // If the system is not public, check for individual access
+    // If the system is not public virtual, check for individual access
     if (!publicAccess) {
       // Require access to accessRoute
       if (!_hasAccess(accessRoute, msg.sender)) revert RouteAccessDenied(accessRoute, msg.sender);
@@ -367,9 +413,9 @@ contract World is Store {
   }
 
   /**
-   * Overload for the function above to check access based on the full system route instead of a parent route (better devex for public systems)
+   * Overload for the function above to check access based on the full system route instead of a parent route (better devex for public virtual systems)
    */
-  function call(string calldata systemRoute, bytes calldata funcSelectorAndArgs) public returns (bytes memory) {
+  function call(string calldata systemRoute, bytes calldata funcSelectorAndArgs) public virtual returns (bytes memory) {
     return call(systemRoute, "", funcSelectorAndArgs);
   }
 

package/src/schemas/AddressArray.sol

@@ -36,11 +36,7 @@ library AddressArraySchemaLib {
   }
 
   /** Set the table's data */
-  function set(
-    uint256 tableId,
-    bytes32 key,
-    address[] memory addresses
-  ) internal {
+  function set(uint256 tableId, bytes32 key, address[] memory addresses) internal {
     bytes memory data = EncodeArray.encode(addresses);
     bytes32[] memory keyTuple = new bytes32[](1);
     keyTuple[0] = key;
@@ -49,17 +45,11 @@ library AddressArraySchemaLib {
 
   /**
    * Push an element to the addresses array
-   * TODO: this is super inefficient right now, need to add support for pushing to arrays to the store core library to avoid reading/writing the entire array
    */
-  function push(
-    uint256 tableId,
-    bytes32 key,
-    address addr
-  ) internal {
+  function push(uint256 tableId, bytes32 key, address addr) internal {
     bytes32[] memory keyTuple = new bytes32[](1);
     keyTuple[0] = key;
-    bytes memory addresses = abi.encodePacked(StoreSwitch.getField(tableId, keyTuple, 0), addr);
-    StoreSwitch.setField(tableId, keyTuple, 0, addresses);
+    StoreSwitch.pushToField(tableId, keyTuple, 0, abi.encodePacked(addr));
   }
 
   /** Get the table's data */
@@ -70,11 +60,7 @@ library AddressArraySchemaLib {
     return decode(blob);
   }
 
-  function get(
-    uint256 tableId,
-    IStore store,
-    bytes32 key
-  ) internal view returns (address[] memory addresses) {
+  function get(uint256 tableId, IStore store, bytes32 key) internal view returns (address[] memory addresses) {
     bytes32[] memory keyTuple = new bytes32[](1);
     keyTuple[0] = key;
     bytes memory blob = store.getRecord(tableId, keyTuple);
@@ -83,6 +69,6 @@ library AddressArraySchemaLib {
 
   function decode(bytes memory blob) internal pure returns (address[] memory addresses) {
     if (blob.length == 0) return new address[](0);
-    SliceLib.getSubslice(blob, 32).decodeArray_address();
+    return SliceLib.getSubslice(blob, 32).decodeArray_address();
   }
 }

package/src/tables/RouteAccess.sol

@@ -3,8 +3,10 @@ pragma solidity >=0.8.0;
 
 /* Autogenerated file. Do not edit manually. */
 
+// Import schema type
 import { SchemaType } from "@latticexyz/schema-type/src/solidity/SchemaType.sol";
 
+// 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";
@@ -14,7 +16,7 @@ import { EncodeArray } from "@latticexyz/store/src/tightcoder/EncodeArray.sol";
 import { Schema, SchemaLib } from "@latticexyz/store/src/Schema.sol";
 import { PackedCounter, PackedCounterLib } from "@latticexyz/store/src/PackedCounter.sol";
 
-uint256 constant _tableId = uint256(keccak256("/world_internals/tables/RouteAccess"));
+uint256 constant _tableId = uint256(keccak256("/RouteAccess"));
 uint256 constant RouteAccessTableId = _tableId;
 
 library RouteAccess {
@@ -26,66 +28,69 @@ library RouteAccess {
     return SchemaLib.encode(_schema);
   }
 
+  /** Get the table's metadata */
+  function getMetadata() internal pure returns (string memory, string[] memory) {
+    string[] memory _fieldNames = new string[](1);
+    _fieldNames[0] = "value";
+    return ("RouteAccess", _fieldNames);
+  }
+
   /** Register the table's schema */
   function registerSchema() internal {
     StoreSwitch.registerSchema(_tableId, getSchema());
   }
 
+  /** Set the table's metadata */
+  function setMetadata() internal {
+    (string memory _tableName, string[] memory _fieldNames) = getMetadata();
+    StoreSwitch.setMetadata(_tableId, _tableName, _fieldNames);
+  }
+
   /** Register the table's schema for the specified store */
   function registerSchema(IStore _store) internal {
     _store.registerSchema(_tableId, getSchema());
   }
 
+  /** Set the table's metadata for the specified store */
+  function setMetadata(IStore _store) internal {
+    (string memory _tableName, string[] memory _fieldNames) = getMetadata();
+    _store.setMetadata(_tableId, _tableName, _fieldNames);
+  }
+
   /** Get value */
   function get(uint256 routeId, address caller) internal view returns (bool value) {
     bytes32[] memory _primaryKeys = new bytes32[](2);
-
-    _primaryKeys[0] = bytes32(uint256(routeId));
-
-    _primaryKeys[1] = bytes32(bytes20(caller));
+    _primaryKeys[0] = bytes32(uint256((routeId)));
+    _primaryKeys[1] = bytes32(bytes20((caller)));
 
     bytes memory _blob = StoreSwitch.getField(_tableId, _primaryKeys, 0);
-    return _toBool(uint8(Bytes.slice1(_blob, 0)));
+    return (_toBool(uint8(Bytes.slice1(_blob, 0))));
   }
 
   /** Get value from the specified store */
-  function get(
-    IStore _store,
-    uint256 routeId,
-    address caller
-  ) internal view returns (bool value) {
+  function get(IStore _store, uint256 routeId, address caller) internal view returns (bool value) {
     bytes32[] memory _primaryKeys = new bytes32[](2);
-
-    _primaryKeys[0] = bytes32(uint256(routeId));
-
-    _primaryKeys[1] = bytes32(bytes20(caller));
+    _primaryKeys[0] = bytes32(uint256((routeId)));
+    _primaryKeys[1] = bytes32(bytes20((caller)));
 
     bytes memory _blob = _store.getField(_tableId, _primaryKeys, 0);
-    return _toBool(uint8(Bytes.slice1(_blob, 0)));
+    return (_toBool(uint8(Bytes.slice1(_blob, 0))));
   }
 
   /** Set value */
-  function set(
-    uint256 routeId,
-    address caller,
-    bool value
-  ) internal {
+  function set(uint256 routeId, address caller, bool value) internal {
     bytes32[] memory _primaryKeys = new bytes32[](2);
+    _primaryKeys[0] = bytes32(uint256((routeId)));
+    _primaryKeys[1] = bytes32(bytes20((caller)));
 
-    _primaryKeys[0] = bytes32(uint256(routeId));
-
-    _primaryKeys[1] = bytes32(bytes20(caller));
-
-    StoreSwitch.setField(_tableId, _primaryKeys, 0, abi.encodePacked(value));
+    StoreSwitch.setField(_tableId, _primaryKeys, 0, abi.encodePacked((value)));
   }
 
   /* Delete all data for given keys */
   function deleteRecord(uint256 routeId, address caller) internal {
     bytes32[] memory _primaryKeys = new bytes32[](2);
-
-    _primaryKeys[0] = bytes32(uint256(routeId));
-
-    _primaryKeys[1] = bytes32(bytes20(caller));
+    _primaryKeys[0] = bytes32(uint256((routeId)));
+    _primaryKeys[1] = bytes32(bytes20((caller)));
 
     StoreSwitch.deleteRecord(_tableId, _primaryKeys);
   }

package/src/tables/SystemTable.sol

@@ -1,43 +1,162 @@
 // SPDX-License-Identifier: MIT
 pragma solidity >=0.8.0;
 
-import { console } from "forge-std/console.sol";
+/* Autogenerated file. Do not edit manually. */
+
+// Import schema type
 import { SchemaType } from "@latticexyz/schema-type/src/solidity/SchemaType.sol";
-import { IStore } from "@latticexyz/store/src/IStore.sol";
-import { Schema } from "@latticexyz/store/src/Schema.sol";
-import { SystemSchemaLib as SchemaLib } from "../schemas/SystemSchema.sol";
 
-// -- User defined schema and tableId --
-uint256 constant tableId = uint256(keccak256("mud.world.table.system"));
+// 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 { SliceLib } from "@latticexyz/store/src/Slice.sol";
+import { EncodeArray } from "@latticexyz/store/src/tightcoder/EncodeArray.sol";
+import { Schema, SchemaLib } from "@latticexyz/store/src/Schema.sol";
+import { PackedCounter, PackedCounterLib } from "@latticexyz/store/src/PackedCounter.sol";
 
-// -- Autogenerated library to interact with tables with this schema --
-// TODO: autogenerate
+uint256 constant _tableId = uint256(keccak256("/SystemTable"));
+uint256 constant SystemTableTableId = _tableId;
 
 library SystemTable {
+  /** Get the table's schema */
+  function getSchema() internal pure returns (Schema) {
+    SchemaType[] memory _schema = new SchemaType[](2);
+    _schema[0] = SchemaType.ADDRESS;
+    _schema[1] = SchemaType.BOOL;
+
+    return SchemaLib.encode(_schema);
+  }
+
+  /** Get the table's metadata */
+  function getMetadata() internal pure returns (string memory, string[] memory) {
+    string[] memory _fieldNames = new string[](2);
+    _fieldNames[0] = "system";
+    _fieldNames[1] = "publicAccess";
+    return ("SystemTable", _fieldNames);
+  }
+
   /** Register the table's schema */
   function registerSchema() internal {
-    SchemaLib.registerSchema(tableId);
+    StoreSwitch.registerSchema(_tableId, getSchema());
+  }
+
+  /** Set the table's metadata */
+  function setMetadata() internal {
+    (string memory _tableName, string[] memory _fieldNames) = getMetadata();
+    StoreSwitch.setMetadata(_tableId, _tableName, _fieldNames);
+  }
+
+  /** Register the table's schema for the specified store */
+  function registerSchema(IStore _store) internal {
+    _store.registerSchema(_tableId, getSchema());
+  }
+
+  /** Set the table's metadata for the specified store */
+  function setMetadata(IStore _store) internal {
+    (string memory _tableName, string[] memory _fieldNames) = getMetadata();
+    _store.setMetadata(_tableId, _tableName, _fieldNames);
   }
 
-  function registerSchema(IStore store) internal {
-    SchemaLib.registerSchema(tableId, store);
+  /** Get system */
+  function getSystem(uint256 routeId) internal view returns (address system) {
+    bytes32[] memory _primaryKeys = new bytes32[](1);
+    _primaryKeys[0] = bytes32(uint256((routeId)));
+
+    bytes memory _blob = StoreSwitch.getField(_tableId, _primaryKeys, 0);
+    return (address(Bytes.slice20(_blob, 0)));
   }
 
-  /** Set the table's data */
-  function set(
-    uint256 routeId,
-    address system,
-    bool publicAccess
-  ) internal {
-    SchemaLib.set(tableId, routeId, system, publicAccess);
+  /** Get system from the specified store */
+  function getSystem(IStore _store, uint256 routeId) internal view returns (address system) {
+    bytes32[] memory _primaryKeys = new bytes32[](1);
+    _primaryKeys[0] = bytes32(uint256((routeId)));
+
+    bytes memory _blob = _store.getField(_tableId, _primaryKeys, 0);
+    return (address(Bytes.slice20(_blob, 0)));
   }
 
-  /** Get the table's data */
-  function get(uint256 routeId) internal view returns (address, bool) {
-    return SchemaLib.get(tableId, routeId);
+  /** Set system */
+  function setSystem(uint256 routeId, address system) internal {
+    bytes32[] memory _primaryKeys = new bytes32[](1);
+    _primaryKeys[0] = bytes32(uint256((routeId)));
+
+    StoreSwitch.setField(_tableId, _primaryKeys, 0, abi.encodePacked((system)));
   }
 
-  function get(IStore store, uint256 routeId) internal view returns (address, bool) {
-    return SchemaLib.get(tableId, store, routeId);
+  /** Get publicAccess */
+  function getPublicAccess(uint256 routeId) internal view returns (bool publicAccess) {
+    bytes32[] memory _primaryKeys = new bytes32[](1);
+    _primaryKeys[0] = bytes32(uint256((routeId)));
+
+    bytes memory _blob = StoreSwitch.getField(_tableId, _primaryKeys, 1);
+    return (_toBool(uint8(Bytes.slice1(_blob, 0))));
+  }
+
+  /** Get publicAccess from the specified store */
+  function getPublicAccess(IStore _store, uint256 routeId) internal view returns (bool publicAccess) {
+    bytes32[] memory _primaryKeys = new bytes32[](1);
+    _primaryKeys[0] = bytes32(uint256((routeId)));
+
+    bytes memory _blob = _store.getField(_tableId, _primaryKeys, 1);
+    return (_toBool(uint8(Bytes.slice1(_blob, 0))));
+  }
+
+  /** Set publicAccess */
+  function setPublicAccess(uint256 routeId, bool publicAccess) internal {
+    bytes32[] memory _primaryKeys = new bytes32[](1);
+    _primaryKeys[0] = bytes32(uint256((routeId)));
+
+    StoreSwitch.setField(_tableId, _primaryKeys, 1, abi.encodePacked((publicAccess)));
+  }
+
+  /** Get the full data */
+  function get(uint256 routeId) internal view returns (address system, bool publicAccess) {
+    bytes32[] memory _primaryKeys = new bytes32[](1);
+    _primaryKeys[0] = bytes32(uint256((routeId)));
+
+    bytes memory _blob = StoreSwitch.getRecord(_tableId, _primaryKeys, getSchema());
+    return decode(_blob);
+  }
+
+  /** Get the full data from the specified store */
+  function get(IStore _store, uint256 routeId) internal view returns (address system, bool publicAccess) {
+    bytes32[] memory _primaryKeys = new bytes32[](1);
+    _primaryKeys[0] = bytes32(uint256((routeId)));
+
+    bytes memory _blob = _store.getRecord(_tableId, _primaryKeys);
+    return decode(_blob);
+  }
+
+  /** Set the full data using individual values */
+  function set(uint256 routeId, address system, bool publicAccess) internal {
+    bytes memory _data = abi.encodePacked(system, publicAccess);
+
+    bytes32[] memory _primaryKeys = new bytes32[](1);
+    _primaryKeys[0] = bytes32(uint256((routeId)));
+
+    StoreSwitch.setRecord(_tableId, _primaryKeys, _data);
+  }
+
+  /** Decode the tightly packed blob using this table's schema */
+  function decode(bytes memory _blob) internal pure returns (address system, bool publicAccess) {
+    system = (address(Bytes.slice20(_blob, 0)));
+
+    publicAccess = (_toBool(uint8(Bytes.slice1(_blob, 20))));
+  }
+
+  /* Delete all data for given keys */
+  function deleteRecord(uint256 routeId) internal {
+    bytes32[] memory _primaryKeys = new bytes32[](1);
+    _primaryKeys[0] = bytes32(uint256((routeId)));
+
+    StoreSwitch.deleteRecord(_tableId, _primaryKeys);
+  }
+}
+
+function _toBool(uint8 value) pure returns (bool result) {
+  assembly {
+    result := value
   }
 }