@latticexyz/cli 1.40.0 → 2.0.0-alpha.0

package/dist/loadStoreConfig-37f99136.d.ts

@@ -1,164 +0,0 @@
-import { SchemaType } from '@latticexyz/schema-type';
-import { z } from 'zod';
-
-interface StoreUserConfig {
-    /** The base route prefix for table ids. Default is "" (empty string) */
-    baseRoute?: string;
-    /** Path for store package imports. Default is "@latticexyz/store/src/" */
-    storeImportPath?: string;
-    /**
-     * Configuration for each table.
-     *
-     * The key is the table name (capitalized).
-     *
-     * The value:
-     *  - SchemaType for a single-value table (aka ECS component).
-     *  - FullTableConfig object for multi-value tables (or for customizable options).
-     */
-    tables: Record<string, SchemaType | FullTableConfig>;
-}
-interface FullTableConfig {
-    /** Output path for the file, and relevant for the table id. The table id will be keccak256(concat(baseRoute,route,tableName)). Default is "tables/" */
-    route?: string;
-    /** Make methods accept `tableId` argument instead of it being a hardcoded constant. Default is false */
-    tableIdArgument?: boolean;
-    /** Include methods that accept a manual `IStore` argument. Default is false. */
-    storeArgument?: boolean;
-    /** Include a data struct and methods for it. Default is false for 1-column tables; true for multi-column tables. */
-    dataStruct?: boolean;
-    /** Table's primary key names mapped to their types. Default is `{ key: SchemaType.BYTES32 }` */
-    primaryKeys?: Record<string, SchemaType>;
-    /** Table's column names mapped to their types. Table name's 1st letter should be lowercase. */
-    schema: Record<string, SchemaType>;
-}
-declare const StoreConfig: z.ZodObject<{
-    baseRoute: z.ZodDefault<z.ZodEffects<z.ZodString, string, string>>;
-    storeImportPath: z.ZodDefault<z.ZodString>;
-    tables: z.ZodRecord<z.ZodEffects<z.ZodString, string, string>, z.ZodUnion<[z.ZodEffects<z.ZodNativeEnum<typeof SchemaType>, Omit<{
-        dataStruct?: boolean | undefined;
-        route: string;
-        tableIdArgument: boolean;
-        storeArgument: boolean;
-        primaryKeys: Record<string, SchemaType>;
-        schema: Record<string, SchemaType>;
-    }, "dataStruct"> & Required<Pick<{
-        dataStruct?: boolean | undefined;
-        route: string;
-        tableIdArgument: boolean;
-        storeArgument: boolean;
-        primaryKeys: Record<string, SchemaType>;
-        schema: Record<string, SchemaType>;
-    }, "dataStruct">>, SchemaType>, z.ZodEffects<z.ZodObject<{
-        route: z.ZodDefault<z.ZodEffects<z.ZodString, string, string>>;
-        tableIdArgument: z.ZodDefault<z.ZodBoolean>;
-        storeArgument: z.ZodDefault<z.ZodBoolean>;
-        primaryKeys: z.ZodDefault<z.ZodRecord<z.ZodEffects<z.ZodString, string, string>, z.ZodEffects<z.ZodNativeEnum<typeof SchemaType>, SchemaType, SchemaType>>>;
-        schema: z.ZodEffects<z.ZodRecord<z.ZodEffects<z.ZodString, string, string>, z.ZodNativeEnum<typeof SchemaType>>, Record<string, SchemaType>, Record<string, SchemaType>>;
-        dataStruct: z.ZodOptional<z.ZodBoolean>;
-    }, "strip", z.ZodTypeAny, {
-        dataStruct?: boolean | undefined;
-        route: string;
-        tableIdArgument: boolean;
-        storeArgument: boolean;
-        primaryKeys: Record<string, SchemaType>;
-        schema: Record<string, SchemaType>;
-    }, {
-        route?: string | undefined;
-        tableIdArgument?: boolean | undefined;
-        storeArgument?: boolean | undefined;
-        primaryKeys?: Record<string, SchemaType> | undefined;
-        dataStruct?: boolean | undefined;
-        schema: Record<string, SchemaType>;
-    }>, Omit<{
-        dataStruct?: boolean | undefined;
-        route: string;
-        tableIdArgument: boolean;
-        storeArgument: boolean;
-        primaryKeys: Record<string, SchemaType>;
-        schema: Record<string, SchemaType>;
-    }, "dataStruct"> & Required<Pick<{
-        dataStruct?: boolean | undefined;
-        route: string;
-        tableIdArgument: boolean;
-        storeArgument: boolean;
-        primaryKeys: Record<string, SchemaType>;
-        schema: Record<string, SchemaType>;
-    }, "dataStruct">>, {
-        route?: string | undefined;
-        tableIdArgument?: boolean | undefined;
-        storeArgument?: boolean | undefined;
-        primaryKeys?: Record<string, SchemaType> | undefined;
-        dataStruct?: boolean | undefined;
-        schema: Record<string, SchemaType>;
-    }>]>>;
-}, "strip", z.ZodTypeAny, {
-    baseRoute: string;
-    storeImportPath: string;
-    tables: Record<string, Omit<{
-        dataStruct?: boolean | undefined;
-        route: string;
-        tableIdArgument: boolean;
-        storeArgument: boolean;
-        primaryKeys: Record<string, SchemaType>;
-        schema: Record<string, SchemaType>;
-    }, "dataStruct"> & Required<Pick<{
-        dataStruct?: boolean | undefined;
-        route: string;
-        tableIdArgument: boolean;
-        storeArgument: boolean;
-        primaryKeys: Record<string, SchemaType>;
-        schema: Record<string, SchemaType>;
-    }, "dataStruct">>>;
-}, {
-    baseRoute?: string | undefined;
-    storeImportPath?: string | undefined;
-    tables: Record<string, SchemaType | {
-        route?: string | undefined;
-        tableIdArgument?: boolean | undefined;
-        storeArgument?: boolean | undefined;
-        primaryKeys?: Record<string, SchemaType> | undefined;
-        dataStruct?: boolean | undefined;
-        schema: Record<string, SchemaType>;
-    }>;
-}>;
-type StoreConfig = z.output<typeof StoreConfig>;
-declare function loadStoreConfig(configPath?: string): Promise<{
-    baseRoute: string;
-    storeImportPath: string;
-    tables: Record<string, Omit<{
-        dataStruct?: boolean | undefined;
-        route: string;
-        tableIdArgument: boolean;
-        storeArgument: boolean;
-        primaryKeys: Record<string, SchemaType>;
-        schema: Record<string, SchemaType>;
-    }, "dataStruct"> & Required<Pick<{
-        dataStruct?: boolean | undefined;
-        route: string;
-        tableIdArgument: boolean;
-        storeArgument: boolean;
-        primaryKeys: Record<string, SchemaType>;
-        schema: Record<string, SchemaType>;
-    }, "dataStruct">>>;
-}>;
-declare function parseStoreConfig(config: unknown): Promise<{
-    baseRoute: string;
-    storeImportPath: string;
-    tables: Record<string, Omit<{
-        dataStruct?: boolean | undefined;
-        route: string;
-        tableIdArgument: boolean;
-        storeArgument: boolean;
-        primaryKeys: Record<string, SchemaType>;
-        schema: Record<string, SchemaType>;
-    }, "dataStruct"> & Required<Pick<{
-        dataStruct?: boolean | undefined;
-        route: string;
-        tableIdArgument: boolean;
-        storeArgument: boolean;
-        primaryKeys: Record<string, SchemaType>;
-        schema: Record<string, SchemaType>;
-    }, "dataStruct">>>;
-}>;
-
-export { StoreUserConfig as S, StoreConfig as a, loadStoreConfig as l, parseStoreConfig as p };

package/dist/render-table/index.d.ts

@@ -1,29 +0,0 @@
-import { R as RenderTableOptions, b as RenderTableField } from '../renderTable-9e6410c5.js';
-export { f as RenderTableDynamicField, b as RenderTableField, R as RenderTableOptions, d as RenderTablePrimaryKey, e as RenderTableStaticField, c as RenderTableType, S as StaticRouteData, a as renderTable, r as renderTablesFromConfig } from '../renderTable-9e6410c5.js';
-import '@latticexyz/schema-type';
-import '../loadStoreConfig-37f99136.js';
-import 'zod';
-
-/**
- * Renders a list of lines
- */
-declare function renderList<T>(list: T[], renderItem: (item: T, index: number) => string): string;
-/**
- * Renders a comma-separated list of arguments for solidity functions, ignoring empty and undefined ones
- */
-declare function renderArguments(args: (string | undefined)[]): string;
-declare function renderCommonData({ staticRouteData, primaryKeys }: RenderTableOptions): {
-    _tableId: string;
-    _typedTableId: string;
-    _keyArgs: string;
-    _typedKeyArgs: string;
-    _primaryKeysDefinition: string;
-};
-
-declare function renderFieldMethods(options: RenderTableOptions): string;
-declare function renderEncodeField(field: RenderTableField): string;
-declare function renderDecodeValueType(typeId: string, staticByteLength: number, offset: number): string;
-
-declare function renderRecordMethods(options: RenderTableOptions): string;
-
-export { renderArguments, renderCommonData, renderDecodeValueType, renderEncodeField, renderFieldMethods, renderList, renderRecordMethods };

package/dist/render-table/index.js

@@ -1,24 +0,0 @@
-import {
-  renderArguments,
-  renderCommonData,
-  renderDecodeValueType,
-  renderEncodeField,
-  renderFieldMethods,
-  renderList,
-  renderRecordMethods,
-  renderTable,
-  renderTablesFromConfig
-} from "../chunk-JNGSW4AP.js";
-import "../chunk-6AQ6LFVZ.js";
-import "../chunk-O6HOO6WA.js";
-export {
-  renderArguments,
-  renderCommonData,
-  renderDecodeValueType,
-  renderEncodeField,
-  renderFieldMethods,
-  renderList,
-  renderRecordMethods,
-  renderTable,
-  renderTablesFromConfig
-};

package/dist/renderTable-9e6410c5.d.ts

@@ -1,72 +0,0 @@
-import { SchemaType } from '@latticexyz/schema-type';
-import { a as StoreConfig } from './loadStoreConfig-37f99136.js';
-
-declare function renderTablesFromConfig(config: StoreConfig): {
-    tableName: string;
-    tableData: Omit<{
-        dataStruct?: boolean | undefined;
-        route: string;
-        tableIdArgument: boolean;
-        storeArgument: boolean;
-        primaryKeys: Record<string, SchemaType>;
-        schema: Record<string, SchemaType>;
-    }, "dataStruct"> & Required<Pick<{
-        dataStruct?: boolean | undefined;
-        route: string;
-        tableIdArgument: boolean;
-        storeArgument: boolean;
-        primaryKeys: Record<string, SchemaType>;
-        schema: Record<string, SchemaType>;
-    }, "dataStruct">>;
-    output: string;
-}[];
-
-interface RenderTableOptions {
-    /** Name of the library to render. */
-    libraryName: string;
-    /** Name of the struct to render. If undefined, struct and its methods aren't rendered. */
-    structName?: string;
-    /** Data used to statically registed the table. If undefined, all methods receive `_tableId` as an argument. */
-    staticRouteData?: StaticRouteData;
-    storeImportPath: string;
-    primaryKeys: RenderTablePrimaryKey[];
-    fields: RenderTableField[];
-    staticFields: RenderTableStaticField[];
-    dynamicFields: RenderTableDynamicField[];
-    /** Whether to render get/set methods for the whole record */
-    withRecordMethods: boolean;
-    /** Whether to render additional methods that accept a manual `IStore` argument */
-    storeArgument: boolean;
-}
-interface StaticRouteData {
-    /** Name of the table id constant to render. */
-    tableIdName: string;
-    baseRoute: string;
-    subRoute: string;
-}
-interface RenderTableType {
-    typeId: string;
-    typeWithLocation: string;
-    enumName: string;
-    staticByteLength: number;
-    isDynamic: boolean;
-}
-interface RenderTablePrimaryKey extends RenderTableType {
-    name: string;
-    isDynamic: false;
-}
-interface RenderTableStaticField extends RenderTableField {
-    isDynamic: false;
-}
-interface RenderTableDynamicField extends RenderTableField {
-    isDynamic: true;
-}
-interface RenderTableField extends RenderTableType {
-    arrayElement: RenderTableType | undefined;
-    name: string;
-    methodNameSuffix: string;
-}
-
-declare function renderTable(options: RenderTableOptions): string;
-
-export { RenderTableOptions as R, StaticRouteData as S, renderTable as a, RenderTableField as b, RenderTableType as c, RenderTablePrimaryKey as d, RenderTableStaticField as e, RenderTableDynamicField as f, renderTablesFromConfig as r };

package/src/config/loadStoreConfig.test-d.ts

@@ -1,11 +0,0 @@
-import { describe, expectTypeOf } from "vitest";
-import { z } from "zod";
-import { StoreConfig, StoreUserConfig } from "./loadStoreConfig.js";
-
-describe("loadStoreConfig", () => {
-  // Typecheck manual interfaces against zod
-  expectTypeOf<StoreUserConfig>().toEqualTypeOf<z.input<typeof StoreConfig>>();
-  // type equality isn't deep for optionals
-  expectTypeOf<StoreUserConfig["tables"][string]>().toEqualTypeOf<z.input<typeof StoreConfig>["tables"][string]>();
-  // TODO If more nested schemas are added, provide separate tests for them
-});

package/src/render-table/common.ts

@@ -1,67 +0,0 @@
-import { RenderTableOptions } from "./types.js";
-
-/**
- * Renders a list of lines
- */
-export function renderList<T>(list: T[], renderItem: (item: T, index: number) => string) {
-  return internalRenderList("", list, renderItem);
-}
-
-/**
- * Renders a comma-separated list of arguments for solidity functions, ignoring empty and undefined ones
- */
-export function renderArguments(args: (string | undefined)[]) {
-  const filteredArgs = args.filter((arg) => arg !== undefined && arg !== "") as string[];
-  return internalRenderList(",", filteredArgs, (arg) => arg);
-}
-
-export function renderCommonData({ staticRouteData, primaryKeys }: RenderTableOptions) {
-  // static route means static tableId as well, and no tableId arguments
-  const _tableId = staticRouteData ? "" : "_tableId";
-  const _typedTableId = staticRouteData ? "" : "uint256 _tableId";
-
-  const _keyArgs = renderArguments(primaryKeys.map(({ name }) => name));
-  const _typedKeyArgs = renderArguments(primaryKeys.map(({ name, typeWithLocation }) => `${typeWithLocation} ${name}`));
-
-  const _primaryKeysDefinition = `
-    bytes32[] memory _primaryKeys = new bytes32[](${primaryKeys.length});
-    ${renderList(
-      primaryKeys,
-      ({ name, typeId, staticByteLength }, index) => `
-    _primaryKeys[${index}] = ${renderValueTypeToBytes32(name, typeId, staticByteLength)};
-    `
-    )}
-  `;
-
-  return {
-    _tableId,
-    _typedTableId,
-    _keyArgs,
-    _typedKeyArgs,
-    _primaryKeysDefinition,
-  };
-}
-
-function renderValueTypeToBytes32(innerText: string, typeId: string, staticByteLength: number) {
-  const bits = staticByteLength * 8;
-
-  if (typeId.match(/^uint\d{1,3}$/)) {
-    return `bytes32(uint256(${innerText}))`;
-  } else if (typeId.match(/^int\d{1,3}$/)) {
-    return `bytes32(uint256(uint${bits}(${innerText})))`;
-  } else if (typeId.match(/^bytes\d{1,2}$/)) {
-    return `bytes32(${innerText})`;
-  } else if (typeId === "address") {
-    return `bytes32(bytes20(${innerText}))`;
-  } else if (typeId === "bool") {
-    return `_boolToBytes32(${innerText})`;
-  } else {
-    throw new Error(`Unknown value type id ${typeId}`);
-  }
-}
-
-function internalRenderList<T>(lineTerminator: string, list: T[], renderItem: (item: T, index: number) => string) {
-  return list
-    .map((item, index) => renderItem(item, index) + (index === list.length - 1 ? "" : lineTerminator))
-    .join("\n");
-}

package/src/render-table/field.ts

@@ -1,132 +0,0 @@
-import { renderArguments, renderCommonData } from "./common.js";
-import { RenderTableField, RenderTableOptions } from "./types.js";
-
-export function renderFieldMethods(options: RenderTableOptions) {
-  const { _typedTableId, _typedKeyArgs, _primaryKeysDefinition } = renderCommonData(options);
-
-  let result = "";
-  for (const [index, field] of options.fields.entries()) {
-    const _typedFieldName = `${field.typeWithLocation} ${field.name}`;
-
-    result += `
-    /** Get ${field.name} */
-    function get${field.methodNameSuffix}(${renderArguments([
-      _typedTableId,
-      _typedKeyArgs,
-    ])}) internal view returns (${_typedFieldName}) {
-      ${_primaryKeysDefinition}
-      bytes memory _blob = StoreSwitch.getField(_tableId, _primaryKeys, ${index});
-      return ${renderDecodeFieldSingle(field)};
-    }
-    `;
-
-    if (options.storeArgument) {
-      result += `
-      /** Get ${field.name} from the specified store */
-      function get${field.methodNameSuffix}(${renderArguments([
-        _typedTableId,
-        `IStore _store`,
-        _typedKeyArgs,
-      ])}) internal view returns (${_typedFieldName}) {
-        ${_primaryKeysDefinition}
-        bytes memory _blob = _store.getField(_tableId, _primaryKeys, ${index});
-        return ${renderDecodeFieldSingle(field)};
-      }
-      `;
-    }
-
-    result += `
-    /** Set ${field.name} */
-    function set${field.methodNameSuffix}(${renderArguments([
-      _typedTableId,
-      _typedKeyArgs,
-      _typedFieldName,
-    ])}) internal {
-      ${_primaryKeysDefinition}
-      StoreSwitch.setField(_tableId, _primaryKeys, ${index}, ${renderEncodeField(field)});
-    }
-    `;
-
-    // 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
-    // (see https://github.com/latticexyz/mud/issues/438)
-    if (field.isDynamic) {
-      const portionData = fieldPortionData(field);
-
-      result += `
-      /** Push ${portionData.title} to ${field.name} */
-      function push${field.methodNameSuffix}(${renderArguments([
-        _typedTableId,
-        _typedKeyArgs,
-        `${portionData.typeWithLocation} ${portionData.name}`,
-      ])}) internal {
-        ${_primaryKeysDefinition}
-        bytes memory _blob = StoreSwitch.getField(_tableId, _primaryKeys, ${index});
-        bytes memory _newBlob = abi.encodePacked(_blob, ${portionData.encodeFunc}(${portionData.name}));
-        StoreSwitch.setField(_tableId, _primaryKeys, ${index}, _newBlob);
-      }
-      `;
-    }
-  }
-  return result;
-}
-
-export function renderEncodeField(field: RenderTableField) {
-  let func;
-  if (field.arrayElement) {
-    func = "EncodeArray.encode";
-  } else if (field.isDynamic) {
-    func = "bytes";
-  } else {
-    func = "abi.encodePacked";
-  }
-  return `${func}(${field.name})`;
-}
-
-export function renderDecodeValueType(typeId: string, staticByteLength: number, offset: number) {
-  const innerSlice = `Bytes.slice${staticByteLength}(_blob, ${offset})`;
-  const bits = staticByteLength * 8;
-
-  if (typeId.match(/^uint\d{1,3}$/) || typeId === "address") {
-    return `${typeId}(${innerSlice})`;
-  } else if (typeId.match(/^int\d{1,3}$/)) {
-    return `${typeId}(uint${bits}(${innerSlice}))`;
-  } else if (typeId.match(/^bytes\d{1,2}$/)) {
-    return innerSlice;
-  } else if (typeId === "bool") {
-    return `_toBool(uint8(${innerSlice}))`;
-  } else {
-    throw new Error(`Unknown value type id ${typeId}`);
-  }
-}
-
-/** bytes/string are dynamic, but aren't really arrays */
-function fieldPortionData(field: RenderTableField) {
-  if (field.arrayElement) {
-    return {
-      typeWithLocation: field.arrayElement.typeWithLocation,
-      name: "_element",
-      encodeFunc: "abi.encodePacked",
-      title: "an element",
-    };
-  } else {
-    return {
-      typeWithLocation: `${field.typeId} memory`,
-      name: "_slice",
-      encodeFunc: "bytes",
-      title: "a slice",
-    };
-  }
-}
-
-function renderDecodeFieldSingle(field: RenderTableField) {
-  const { typeId, isDynamic, arrayElement } = field;
-  if (arrayElement) {
-    // arrays
-    return `SliceLib.getSubslice(_blob, 0, _blob.length).decodeArray_${arrayElement.typeId}()`;
-  } else if (isDynamic) {
-    // bytes/string
-    return `${typeId}(_blob)`;
-  } else {
-    return renderDecodeValueType(typeId, field.staticByteLength, 0);
-  }
-}

package/src/render-table/index.ts

@@ -1,6 +0,0 @@
-export * from "./common.js";
-export * from "./field.js";
-export * from "./record.js";
-export * from "./renderTable.js";
-export * from "./renderTablesFromConfig.js";
-export * from "./types.js";

package/src/render-table/record.ts

@@ -1,176 +0,0 @@
-import { renderList, renderArguments, renderCommonData } from "./common.js";
-import { renderDecodeValueType, renderEncodeField } from "./field.js";
-import { RenderTableDynamicField, RenderTableOptions, RenderTableStaticField } from "./types.js";
-
-export function renderRecordMethods(options: RenderTableOptions) {
-  const { staticFields, dynamicFields, structName, storeArgument } = options;
-  const { _tableId, _typedTableId, _keyArgs, _typedKeyArgs, _primaryKeysDefinition } = renderCommonData(options);
-
-  let result = `
-  /** Get the full data */
-  function get(${renderArguments([_typedTableId, _typedKeyArgs])}) internal view returns (${renderDecodedRecord(
-    options
-  )}) {
-    ${_primaryKeysDefinition}
-    bytes memory _blob = StoreSwitch.getRecord(_tableId, _primaryKeys, getSchema());
-    return decode(_blob);
-  }
-  `;
-
-  if (storeArgument) {
-    result += `
-    /** Get the full data from the specified store */
-    function get(${renderArguments([
-      _typedTableId,
-      `IStore _store`,
-      _typedKeyArgs,
-    ])}) internal view returns (${renderDecodedRecord(options)}) {
-      ${_primaryKeysDefinition}
-      bytes memory _blob = _store.getRecord(_tableId, _primaryKeys);
-      return decode(_blob);
-    }
-    `;
-  }
-
-  result += `
-  /** Set the full data using individual values */
-  function set(${renderArguments([
-    _typedTableId,
-    _typedKeyArgs,
-    renderArguments(options.fields.map(({ name, typeWithLocation }) => `${typeWithLocation} ${name}`)),
-  ])}) internal {
-    ${renderEncodedLengths(dynamicFields)}
-    bytes memory _data = abi.encodePacked(${renderArguments([
-      renderArguments(staticFields.map(({ name }) => name)),
-      // TODO try gas optimization (preallocate for all, encodePacked statics, and direct encode dynamics)
-      // (see https://github.com/latticexyz/mud/issues/444)
-      ...(dynamicFields.length === 0
-        ? []
-        : ["_encodedLengths.unwrap()", renderArguments(dynamicFields.map((field) => renderEncodeField(field)))]),
-    ])});
-
-    ${_primaryKeysDefinition}
-
-    StoreSwitch.setRecord(_tableId, _primaryKeys, _data);
-  }
-  `;
-
-  if (structName !== undefined) {
-    result += `
-    /** Set the full data using the data struct */
-    function set(${renderArguments([_typedTableId, _typedKeyArgs, `${structName} memory _table`])}) internal {
-      set(${renderArguments([
-        _tableId,
-        _keyArgs,
-        renderArguments(options.fields.map(({ name }) => `_table.${name}`)),
-      ])});
-    }
-    `;
-  }
-
-  result += renderDecodeFunction(options);
-
-  return result;
-}
-
-// Renders the `decode` function that parses a bytes blob into the table data
-function renderDecodeFunction({ structName, fields, staticFields, dynamicFields }: RenderTableOptions) {
-  // either set struct properties, or just variables
-  const renderedDecodedRecord = structName
-    ? `${structName} memory _table`
-    : renderArguments(fields.map(({ name, typeWithLocation }) => `${typeWithLocation} ${name}`));
-  const fieldNamePrefix = structName ? "_table." : "";
-
-  // Static field offsets
-  const staticOffsets = staticFields.map(() => 0);
-  let _acc = 0;
-  for (const [index, field] of staticFields.entries()) {
-    staticOffsets[index] = _acc;
-    _acc += field.staticByteLength;
-  }
-
-  if (dynamicFields.length > 0) {
-    const totalStaticLength = staticFields.reduce((acc, { staticByteLength }) => acc + staticByteLength, 0);
-    // decode static (optionally) and dynamic data
-    return `
-    /** Decode the tightly packed blob using this table's schema */
-    function decode(bytes memory _blob) internal view returns (${renderedDecodedRecord}) {
-      // ${totalStaticLength} is the total byte length of static data
-      PackedCounter _encodedLengths = PackedCounter.wrap(Bytes.slice32(_blob, ${totalStaticLength})); 
-
-      ${renderList(
-        staticFields,
-        (field, index) => `
-        ${fieldNamePrefix}${field.name} = ${renderDecodeStaticFieldPartial(field, staticOffsets[index])};
-        `
-      )}
-      uint256 _start;
-      uint256 _end = ${totalStaticLength + 32};
-      ${renderList(
-        dynamicFields,
-        (field, index) => `
-        _start = _end;
-        _end += _encodedLengths.atIndex(${index});
-        ${fieldNamePrefix}${field.name} = ${renderDecodeDynamicFieldPartial(field)};
-        `
-      )}
-    }
-  `;
-  } else {
-    // decode only static data
-    return `
-    /** Decode the tightly packed blob using this table's schema */
-    function decode(bytes memory _blob) internal pure returns (${renderedDecodedRecord}) {
-      ${renderList(
-        staticFields,
-        (field, index) => `
-        ${fieldNamePrefix}${field.name} = ${renderDecodeStaticFieldPartial(field, staticOffsets[index])};
-        `
-      )}
-    }
-    `;
-  }
-}
-
-// contents of `returns (...)` for record getter/decoder
-function renderDecodedRecord({ structName, fields }: RenderTableOptions) {
-  if (structName) {
-    return `${structName} memory _table`;
-  } else {
-    return renderArguments(fields.map(({ name, typeWithLocation }) => `${typeWithLocation} ${name}`));
-  }
-}
-
-function renderDecodeDynamicFieldPartial(field: RenderTableDynamicField) {
-  const { typeId, arrayElement } = field;
-  if (arrayElement) {
-    // arrays
-    return `SliceLib.getSubslice(_blob, _start, _end).decodeArray_${arrayElement.typeId}()`;
-  } else {
-    // bytes/string
-    return `${typeId}(SliceLib.getSubslice(_blob, _start, _end).toBytes())`;
-  }
-}
-
-function renderDecodeStaticFieldPartial(field: RenderTableStaticField, start: number) {
-  const { typeId, staticByteLength } = field;
-  return renderDecodeValueType(typeId, staticByteLength, start);
-}
-
-function renderEncodedLengths(dynamicFields: RenderTableDynamicField[]) {
-  if (dynamicFields.length > 0) {
-    return `
-    uint16[] memory _counters = new uint16[](${dynamicFields.length});
-    ${renderList(dynamicFields, ({ name, arrayElement }, index) => {
-      if (arrayElement) {
-        return `_counters[${index}] = uint16(${name}.length * ${arrayElement.staticByteLength});`;
-      } else {
-        return `_counters[${index}] = uint16(bytes(${name}).length);`;
-      }
-    })}
-    PackedCounter _encodedLengths = PackedCounterLib.pack(_counters);
-    `;
-  } else {
-    return "";
-  }
-}