@latticexyz/store 2.2.18-ebe1aea8d4afb690ce1c7c2bcb42dc0f1faf6e77 → 2.2.18

package/dist/internal.js

@@ -1,2 +1,303 @@
-import{g as d}from"./chunk-4TACS4IT.js";import{A as ue,B as xe,C as be,D as Se,E as Te,F as ke,G as Le,H as he,I as Be,J as Re,K as ve,L as Ae,M as Pe,N as De,O as Ne,P as He,Q as Ee,R as Ge,S as _e,T as Ce,U as Ke,V as Ie,a as $,b as q,c as F,d as J,e as Q,f as U,g as W,h as X,i as Y,j as Z,k as ee,l as te,m as oe,n as re,o as ae,p as ne,q as se,r as ce,s as ie,t as me,u as de,v as pe,w as le,x as ge,y as ye,z as fe}from"./chunk-5YJ4WITG.js";var p={staticData:"0x",encodedLengths:"0x",dynamicData:"0x"};import{toEventSelector as k,numberToHex as y,formatLog as L,parseEventLogs as h}from"viem";import g from"debug";var l=g("mud:store");l.log=console.debug.bind(console);var T=g("mud:store");T.log=console.error.bind(console);import{hexToResource as B,resourceToLabel as R}from"@latticexyz/common";async function et(r,{address:a,tableId:t,fromBlock:e,toBlock:o}={}){let n=[d.map(k),t??null],s=t?Array.isArray(t)?t:[t]:[],c=a?Array.isArray(a)?a:[a]:[];l(`getting store logs for ${s.length?s.map(B).map(R).join(", "):"all tables"} at ${c.length?c.join(", "):"any address"}`);let m=(await r.request({method:"eth_getLogs",params:[{address:a,topics:n,fromBlock:typeof e=="bigint"?y(e):e,toBlock:typeof o=="bigint"?y(o):o}]})).map(S=>L(S));return h({abi:d,args:{tableId:t},logs:m,strict:!0})}import{size as v}from"viem";import{logSort as A,spliceHex as f}from"@latticexyz/common";function P(r){return[r.address,r.args.tableId,r.args.keyTuple.join(",")].join(":")}function st(r){let a=r.slice().sort(A),t=new Map;for(let e of a){let o=P(e);if(e.eventName==="Store_SetRecord")t.delete(o),t.set(o,e);else if(e.eventName==="Store_SpliceStaticData"){let n=t.get(o),{staticData:s,encodedLengths:c,dynamicData:i}=n?.args??p,m={...e,eventName:"Store_SetRecord",args:{tableId:e.args.tableId,keyTuple:e.args.keyTuple,staticData:f(s,e.args.start,v(e.args.data),e.args.data),encodedLengths:c,dynamicData:i}};t.delete(o),t.set(o,m)}else if(e.eventName==="Store_SpliceDynamicData"){let n=t.get(o),{staticData:s,dynamicData:c}=n?.args??p,i={...e,eventName:"Store_SetRecord",args:{tableId:e.args.tableId,keyTuple:e.args.keyTuple,staticData:s,encodedLengths:e.args.encodedLengths,dynamicData:f(c,e.args.start,e.args.deleteCount,e.args.data)}};t.delete(o),t.set(o,i)}else e.eventName==="Store_DeleteRecord"&&t.delete(o)}return Array.from(t.values())}import{decodeKey as D,decodeValueArgs as N,getKeySchema as H,getSchemaTypes as u,getValueSchema as E}from"@latticexyz/protocol-parser/internal";function dt({table:r,log:a}){let t=u(H(r)),e=u(E(r)),o=D(t,a.args.keyTuple),n=N(e,a.args);return{...o,...n}}import{decodeValueArgs as G,getKeyTuple as _,getSchemaTypes as C,getValueSchema as K}from"@latticexyz/protocol-parser/internal";import{readContract as I}from"viem/actions";import{getAction as V}from"viem/utils";async function xt(r,{address:a,table:t,key:e,blockTag:o}){let[n,s,c]=await V(r,I,"readContract")({address:a,abi:j,functionName:"getRecord",args:[t.tableId,_(t,e)],blockTag:o});return{...e,...G(C(K(t)),{staticData:n,encodedLengths:s,dynamicData:c})}}var j=[{type:"function",name:"getRecord",inputs:[{name:"tableId",type:"bytes32",internalType:"ResourceId"},{name:"keyTuple",type:"bytes32[]",internalType:"bytes32[]"}],outputs:[{name:"staticData",type:"bytes",internalType:"bytes"},{name:"encodedLengths",type:"bytes32",internalType:"EncodedLengths"},{name:"dynamicData",type:"bytes",internalType:"bytes"}],stateMutability:"view"}];import{concatHex as w,hexToBigInt as x,keccak256 as b,numberToHex as O,toBytes as z}from"viem";var M=x(b(z("mud.store")));function kt(r,a){return O(M^x(b(w([r,...a]))),{size:32})}export{te as AbiTypeScope,U as CODEGEN_DEFAULTS,Z as CONFIG_DEFAULTS,le as NoStaticKeyFieldError,ee as Scope,W as TABLE_CODEGEN_DEFAULTS,Y as TABLE_DEFAULTS,X as TABLE_DEPLOY_DEFAULTS,Ee as defineNamespaces,ne as defineSchema,Ie as defineStore,pe as defineTable,ue as defineTableShorthand,Se as defineTables,p as emptyRecord,fe as expandTableShorthand,oe as extendScope,_e as extendedScope,Te as extractInternalType,Ge as flattenNamespacedTables,st as flattenStoreLogs,$ as get,q as getPath,xt as getRecord,kt as getStaticDataLocation,et as getStoreLogs,F as hasOwnKey,J as isObject,se as isSchemaInput,ge as isTableShorthandInput,ke as isUserTypes,ce as isValidPrimaryKey,dt as logToRecord,ve as mapEnums,Q as mergeIfUndefined,Ae as resolveCodegen,Re as resolveEnums,De as resolveNamespace,He as resolveNamespaces,ae as resolveSchema,Ke as resolveStore,de as resolveTable,me as resolveTableCodegen,be as resolveTables,Be as scopeWithEnums,Le as scopeWithUserTypes,Pe as validateNamespace,Ne as validateNamespaces,re as validateSchema,Ce as validateStore,ie as validateTable,ye as validateTableShorthand,xe as validateTables,he as validateUserTypes};
+import {
+  storeEventsAbi
+} from "./chunk-ZBDA5HOY.js";
+import {
+  AbiTypeScope,
+  CODEGEN_DEFAULTS,
+  CONFIG_DEFAULTS,
+  NoStaticKeyFieldError,
+  Scope,
+  TABLE_CODEGEN_DEFAULTS,
+  TABLE_DEFAULTS,
+  TABLE_DEPLOY_DEFAULTS,
+  defineNamespaces,
+  defineSchema,
+  defineStore,
+  defineTable,
+  defineTableShorthand,
+  defineTables,
+  expandTableShorthand,
+  extendScope,
+  extendedScope,
+  extractInternalType,
+  flattenNamespacedTables,
+  get,
+  getPath,
+  hasOwnKey,
+  isObject,
+  isSchemaInput,
+  isTableShorthandInput,
+  isUserTypes,
+  isValidPrimaryKey,
+  mapEnums,
+  mergeIfUndefined,
+  resolveCodegen,
+  resolveEnums,
+  resolveNamespace,
+  resolveNamespaces,
+  resolveSchema,
+  resolveStore,
+  resolveTable,
+  resolveTableCodegen,
+  resolveTables,
+  scopeWithEnums,
+  scopeWithUserTypes,
+  validateNamespace,
+  validateNamespaces,
+  validateSchema,
+  validateStore,
+  validateTable,
+  validateTableShorthand,
+  validateTables,
+  validateUserTypes
+} from "./chunk-FULF4J63.js";
+
+// ts/common.ts
+var emptyRecord = {
+  staticData: "0x",
+  encodedLengths: "0x",
+  dynamicData: "0x"
+};
+
+// ts/getStoreLogs.ts
+import {
+  toEventSelector,
+  numberToHex,
+  formatLog,
+  parseEventLogs
+} from "viem";
+
+// ts/debug.ts
+import createDebug from "debug";
+var debug = createDebug("mud:store");
+debug.log = console.debug.bind(console);
+var error = createDebug("mud:store");
+error.log = console.error.bind(console);
+
+// ts/getStoreLogs.ts
+import { hexToResource, resourceToLabel } from "@latticexyz/common";
+async function getStoreLogs(client, { address, tableId, fromBlock, toBlock } = {}) {
+  const topics = [storeEventsAbi.map(toEventSelector), tableId ?? null];
+  const tableIds = tableId ? Array.isArray(tableId) ? tableId : [tableId] : [];
+  const addresses = address ? Array.isArray(address) ? address : [address] : [];
+  debug(
+    `getting store logs for ${tableIds.length ? tableIds.map(hexToResource).map(resourceToLabel).join(", ") : "all tables"} at ${addresses.length ? addresses.join(", ") : "any address"}`
+  );
+  const logs = await client.request({
+    method: "eth_getLogs",
+    params: [
+      {
+        address,
+        topics,
+        fromBlock: typeof fromBlock === "bigint" ? numberToHex(fromBlock) : fromBlock,
+        toBlock: typeof toBlock === "bigint" ? numberToHex(toBlock) : toBlock
+      }
+    ]
+  });
+  const formattedLogs = logs.map((log) => formatLog(log));
+  return parseEventLogs({
+    abi: storeEventsAbi,
+    args: { tableId },
+    logs: formattedLogs,
+    strict: true
+  });
+}
+
+// ts/flattenStoreLogs.ts
+import { size } from "viem";
+import { logSort, spliceHex } from "@latticexyz/common";
+function getKey(log) {
+  return [log.address, log.args.tableId, log.args.keyTuple.join(",")].join(":");
+}
+function flattenStoreLogs(logs) {
+  const sortedLogs = logs.slice().sort(logSort);
+  const records = /* @__PURE__ */ new Map();
+  for (const log of sortedLogs) {
+    const key = getKey(log);
+    if (log.eventName === "Store_SetRecord") {
+      records.delete(key);
+      records.set(key, log);
+    } else if (log.eventName === "Store_SpliceStaticData") {
+      const previousRecord = records.get(key);
+      const { staticData, encodedLengths, dynamicData } = previousRecord?.args ?? emptyRecord;
+      const nextRecord = {
+        ...log,
+        eventName: "Store_SetRecord",
+        args: {
+          tableId: log.args.tableId,
+          keyTuple: log.args.keyTuple,
+          staticData: spliceHex(staticData, log.args.start, size(log.args.data), log.args.data),
+          encodedLengths,
+          dynamicData
+        }
+      };
+      records.delete(key);
+      records.set(key, nextRecord);
+    } else if (log.eventName === "Store_SpliceDynamicData") {
+      const previousRecord = records.get(key);
+      const { staticData, dynamicData } = previousRecord?.args ?? emptyRecord;
+      const nextRecord = {
+        ...log,
+        eventName: "Store_SetRecord",
+        args: {
+          tableId: log.args.tableId,
+          keyTuple: log.args.keyTuple,
+          staticData,
+          encodedLengths: log.args.encodedLengths,
+          dynamicData: spliceHex(dynamicData, log.args.start, log.args.deleteCount, log.args.data)
+        }
+      };
+      records.delete(key);
+      records.set(key, nextRecord);
+    } else if (log.eventName === "Store_DeleteRecord") {
+      records.delete(key);
+    }
+  }
+  return Array.from(records.values());
+}
+
+// ts/logToRecord.ts
+import {
+  decodeKey,
+  decodeValueArgs,
+  getKeySchema,
+  getSchemaTypes,
+  getValueSchema
+} from "@latticexyz/protocol-parser/internal";
+function logToRecord({
+  table,
+  log
+}) {
+  const keySchema = getSchemaTypes(getKeySchema(table));
+  const valueSchema = getSchemaTypes(getValueSchema(table));
+  const key = decodeKey(keySchema, log.args.keyTuple);
+  const value = decodeValueArgs(valueSchema, log.args);
+  return { ...key, ...value };
+}
+
+// ts/getRecord.ts
+import {
+  decodeValueArgs as decodeValueArgs2,
+  getKeyTuple,
+  getSchemaTypes as getSchemaTypes2,
+  getValueSchema as getValueSchema2
+} from "@latticexyz/protocol-parser/internal";
+import { readContract } from "viem/actions";
+import { getAction } from "viem/utils";
+async function getRecord(client, { address, table, key, blockTag }) {
+  const [staticData, encodedLengths, dynamicData] = await getAction(
+    client,
+    readContract,
+    "readContract"
+  )({
+    address,
+    abi,
+    functionName: "getRecord",
+    args: [table.tableId, getKeyTuple(table, key)],
+    blockTag
+  });
+  return {
+    ...key,
+    ...decodeValueArgs2(getSchemaTypes2(getValueSchema2(table)), { staticData, encodedLengths, dynamicData })
+  };
+}
+var abi = [
+  {
+    type: "function",
+    name: "getRecord",
+    inputs: [
+      {
+        name: "tableId",
+        type: "bytes32",
+        internalType: "ResourceId"
+      },
+      {
+        name: "keyTuple",
+        type: "bytes32[]",
+        internalType: "bytes32[]"
+      }
+    ],
+    outputs: [
+      {
+        name: "staticData",
+        type: "bytes",
+        internalType: "bytes"
+      },
+      {
+        name: "encodedLengths",
+        type: "bytes32",
+        internalType: "EncodedLengths"
+      },
+      {
+        name: "dynamicData",
+        type: "bytes",
+        internalType: "bytes"
+      }
+    ],
+    stateMutability: "view"
+  }
+];
+
+// ts/getStaticDataLocation.ts
+import { concatHex, hexToBigInt, keccak256, numberToHex as numberToHex2, toBytes } from "viem";
+var SLOT = hexToBigInt(keccak256(toBytes("mud.store")));
+function getStaticDataLocation(tableId, keyTuple) {
+  return numberToHex2(SLOT ^ hexToBigInt(keccak256(concatHex([tableId, ...keyTuple]))), { size: 32 });
+}
+export {
+  AbiTypeScope,
+  CODEGEN_DEFAULTS,
+  CONFIG_DEFAULTS,
+  NoStaticKeyFieldError,
+  Scope,
+  TABLE_CODEGEN_DEFAULTS,
+  TABLE_DEFAULTS,
+  TABLE_DEPLOY_DEFAULTS,
+  defineNamespaces,
+  defineSchema,
+  defineStore,
+  defineTable,
+  defineTableShorthand,
+  defineTables,
+  emptyRecord,
+  expandTableShorthand,
+  extendScope,
+  extendedScope,
+  extractInternalType,
+  flattenNamespacedTables,
+  flattenStoreLogs,
+  get,
+  getPath,
+  getRecord,
+  getStaticDataLocation,
+  getStoreLogs,
+  hasOwnKey,
+  isObject,
+  isSchemaInput,
+  isTableShorthandInput,
+  isUserTypes,
+  isValidPrimaryKey,
+  logToRecord,
+  mapEnums,
+  mergeIfUndefined,
+  resolveCodegen,
+  resolveEnums,
+  resolveNamespace,
+  resolveNamespaces,
+  resolveSchema,
+  resolveStore,
+  resolveTable,
+  resolveTableCodegen,
+  resolveTables,
+  scopeWithEnums,
+  scopeWithUserTypes,
+  validateNamespace,
+  validateNamespaces,
+  validateSchema,
+  validateStore,
+  validateTable,
+  validateTableShorthand,
+  validateTables,
+  validateUserTypes
+};
 //# sourceMappingURL=internal.js.map

package/dist/internal.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../ts/common.ts","../ts/getStoreLogs.ts","../ts/debug.ts","../ts/flattenStoreLogs.ts","../ts/logToRecord.ts","../ts/getRecord.ts","../ts/getStaticDataLocation.ts"],"sourcesContent":["import { SchemaAbiType, SchemaAbiTypeToPrimitiveType, StaticAbiType } from \"@latticexyz/schema-type/internal\";\n\nexport type KeySchema = {\n  readonly [k: string]: {\n    readonly type: StaticAbiType;\n  };\n};\nexport type ValueSchema = {\n  readonly [k: string]: {\n    readonly type: SchemaAbiType;\n  };\n};\n\n/** Map a table schema like `{ value: { type: \"uint256\" } }` to its primitive types like `{ value: bigint }` */\nexport type SchemaToPrimitives<schema extends ValueSchema> = {\n  readonly [key in keyof schema]: SchemaAbiTypeToPrimitiveType<schema[key][\"type\"]>;\n};\n\nexport const emptyRecord = {\n  staticData: \"0x\",\n  encodedLengths: \"0x\",\n  dynamicData: \"0x\",\n} as const;\n","import {\n  BlockNumber,\n  BlockTag,\n  Address,\n  Log,\n  Hex,\n  GetLogsErrorType,\n  Client,\n  toEventSelector,\n  LogTopic,\n  RpcLog,\n  numberToHex,\n  formatLog,\n  parseEventLogs,\n} from \"viem\";\nimport { storeEventsAbi } from \"./storeEventsAbi\";\nimport { debug } from \"./debug\";\nimport { hexToResource, resourceToLabel } from \"@latticexyz/common\";\n\nexport type GetStoreLogsParameters<\n  fromBlock extends BlockNumber | BlockTag | undefined = undefined,\n  toBlock extends BlockNumber | BlockTag | undefined = undefined,\n> = {\n  /** Store address or list of store addresses from which logs originated */\n  address?: Address | Address[] | undefined;\n  /** Optionally match a specific table ID or list of table IDs */\n  tableId?: Hex | Hex[] | undefined;\n  /** Block number or tag after which to include logs */\n  fromBlock?: fromBlock | BlockNumber | BlockTag | undefined;\n  /** Block number or tag before which to include logs */\n  toBlock?: toBlock | BlockNumber | BlockTag | undefined;\n};\n\nexport type GetStoreLogsReturnType<\n  fromBlock extends BlockNumber | BlockTag | undefined = undefined,\n  toBlock extends BlockNumber | BlockTag | undefined = undefined,\n  _pending extends boolean = (fromBlock extends \"pending\" ? true : false) | (toBlock extends \"pending\" ? true : false),\n> = Log<bigint, number, _pending, undefined, true, storeEventsAbi, undefined>[];\n\nexport type GetStoreLogsErrorType = GetLogsErrorType;\n\n/**\n * Returns an unordered list of store event logs matching the provided parameters.\n *\n * @param client - Client to use\n * @param parameters - {@link GetStoreLogsParameters}\n * @returns A list of event logs. {@link GetStoreLogsReturnType}\n *\n * @example\n * import { createClient, http } from 'viem'\n * import { mainnet } from 'viem/chains'\n * import { getStoreLogs } from '@latticexyz/store'\n *\n * const client = createPublicClient({\n *   chain: mainnet,\n *   transport: http(),\n * })\n * const storeLogs = await getStoreLogs(client)\n */\nexport async function getStoreLogs<\n  fromBlock extends BlockNumber | BlockTag | undefined = undefined,\n  toBlock extends BlockNumber | BlockTag | undefined = undefined,\n>(\n  client: Client,\n  { address, tableId, fromBlock, toBlock }: GetStoreLogsParameters<fromBlock, toBlock> = {},\n): Promise<GetStoreLogsReturnType<fromBlock, toBlock>> {\n  /**\n   * Note that this implementation follows Viem's [`getLogs`][0] action:\n   * https://github.com/wevm/viem/blob/main/src/actions/public/getLogs.ts\n   *\n   * It's adapted to allow filtering by table ID(s), which Viem's `getLogs`\n   * does not support due to how it builds topics.\n   */\n\n  const topics: LogTopic[] = [storeEventsAbi.map(toEventSelector), tableId ?? null];\n\n  const tableIds = tableId ? (Array.isArray(tableId) ? tableId : [tableId]) : [];\n  const addresses = address ? (Array.isArray(address) ? address : [address]) : [];\n  debug(\n    `getting store logs for ${\n      tableIds.length ? tableIds.map(hexToResource).map(resourceToLabel).join(\", \") : \"all tables\"\n    } at ${addresses.length ? addresses.join(\", \") : \"any address\"}`,\n  );\n\n  const logs: RpcLog[] = await client.request({\n    method: \"eth_getLogs\",\n    params: [\n      {\n        address,\n        topics,\n        fromBlock: typeof fromBlock === \"bigint\" ? numberToHex(fromBlock) : fromBlock,\n        toBlock: typeof toBlock === \"bigint\" ? numberToHex(toBlock) : toBlock,\n      },\n    ],\n  });\n\n  const formattedLogs = logs.map((log) => formatLog(log));\n  return parseEventLogs({\n    abi: storeEventsAbi,\n    args: { tableId },\n    logs: formattedLogs,\n    strict: true,\n  }) as GetStoreLogsReturnType<fromBlock, toBlock>;\n}\n","import createDebug from \"debug\";\n\nexport const debug = createDebug(\"mud:store\");\ndebug.log = console.debug.bind(console);\n\nexport const error = createDebug(\"mud:store\");\nerror.log = console.error.bind(console);\n","import { Log, size } from \"viem\";\nimport { storeEventsAbi } from \"./storeEventsAbi\";\nimport { emptyRecord } from \"./common\";\nimport { StoreLog, StoreSetRecordLog } from \"./storeLog\";\nimport { logSort, spliceHex } from \"@latticexyz/common\";\n\nfunction getKey(log: Log<bigint, number, boolean, undefined, true, storeEventsAbi, undefined>) {\n  return [log.address, log.args.tableId, log.args.keyTuple.join(\",\")].join(\":\");\n}\n\nexport function flattenStoreLogs(logs: StoreLog[]): StoreSetRecordLog[] {\n  const sortedLogs = logs.slice().sort(logSort);\n  const records = new Map<string, StoreSetRecordLog>();\n\n  for (const log of sortedLogs) {\n    const key = getKey(log);\n\n    if (log.eventName === \"Store_SetRecord\") {\n      // maps preserve order, so always delete then set so the record gets\n      // added to the end of the map, thus preserving the log order\n      records.delete(key);\n      records.set(key, log);\n    } else if (log.eventName === \"Store_SpliceStaticData\") {\n      const previousRecord = records.get(key);\n      const { staticData, encodedLengths, dynamicData } = previousRecord?.args ?? emptyRecord;\n      const nextRecord = {\n        ...log,\n        eventName: \"Store_SetRecord\",\n        args: {\n          tableId: log.args.tableId,\n          keyTuple: log.args.keyTuple,\n          staticData: spliceHex(staticData, log.args.start, size(log.args.data), log.args.data),\n          encodedLengths,\n          dynamicData,\n        },\n      } satisfies StoreSetRecordLog;\n      // maps preserve order, so always delete then set so the record gets\n      // added to the end of the map, thus preserving the log order\n      records.delete(key);\n      records.set(key, nextRecord);\n    } else if (log.eventName === \"Store_SpliceDynamicData\") {\n      const previousRecord = records.get(key);\n      const { staticData, dynamicData } = previousRecord?.args ?? emptyRecord;\n      const nextRecord = {\n        ...log,\n        eventName: \"Store_SetRecord\",\n        args: {\n          tableId: log.args.tableId,\n          keyTuple: log.args.keyTuple,\n          staticData,\n          encodedLengths: log.args.encodedLengths,\n          dynamicData: spliceHex(dynamicData, log.args.start, log.args.deleteCount, log.args.data),\n        },\n      } satisfies StoreSetRecordLog;\n      // maps preserve order, so always delete then set so the record gets\n      // added to the end of the map, thus preserving the log order\n      records.delete(key);\n      records.set(key, nextRecord);\n    } else if (log.eventName === \"Store_DeleteRecord\") {\n      records.delete(key);\n    }\n  }\n\n  return Array.from(records.values());\n}\n","import { Table } from \"@latticexyz/config\";\nimport {\n  decodeKey,\n  decodeValueArgs,\n  getKeySchema,\n  getSchemaPrimitives,\n  getSchemaTypes,\n  getValueSchema,\n} from \"@latticexyz/protocol-parser/internal\";\nimport { StoreLog } from \"./storeLog\";\n\ntype PartialTable = Pick<Table, \"schema\" | \"key\">;\ntype PartialLog = Pick<Extract<StoreLog, { eventName: \"Store_SetRecord\" }>, \"args\">;\n\nexport type LogToRecordArgs<table extends PartialTable> = {\n  table: table;\n  log: PartialLog;\n};\n\nexport function logToRecord<table extends PartialTable>({\n  table,\n  log,\n}: LogToRecordArgs<table>): getSchemaPrimitives<table[\"schema\"]> {\n  const keySchema = getSchemaTypes(getKeySchema(table));\n  const valueSchema = getSchemaTypes(getValueSchema(table));\n  const key = decodeKey(keySchema, log.args.keyTuple);\n  const value = decodeValueArgs(valueSchema, log.args);\n  return { ...key, ...value };\n}\n","import { Address, Client, Hex } from \"viem\";\nimport { Table } from \"@latticexyz/config\";\nimport {\n  decodeValueArgs,\n  getKeySchema,\n  getKeyTuple,\n  getSchemaPrimitives,\n  getSchemaTypes,\n  getValueSchema,\n} from \"@latticexyz/protocol-parser/internal\";\nimport { readContract } from \"viem/actions\";\nimport { getAction } from \"viem/utils\";\n\nexport type GetRecordOptions<table extends Table> = {\n  address: Address;\n  table: table;\n  key: getSchemaPrimitives<getKeySchema<table>>;\n  blockTag?: \"latest\" | \"pending\";\n};\n\nexport async function getRecord<table extends Table>(\n  client: Client,\n  { address, table, key, blockTag }: GetRecordOptions<table>,\n): Promise<getSchemaPrimitives<table[\"schema\"]>> {\n  const [staticData, encodedLengths, dynamicData] = await getAction(\n    client,\n    readContract,\n    \"readContract\",\n  )({\n    address,\n    abi,\n    functionName: \"getRecord\",\n    args: [table.tableId, getKeyTuple(table, key) as readonly Hex[]],\n    blockTag,\n  });\n\n  return {\n    ...key,\n    ...decodeValueArgs(getSchemaTypes(getValueSchema(table)), { staticData, encodedLengths, dynamicData }),\n  };\n}\n\nconst 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] as const;\n","import { Hex, concatHex, hexToBigInt, keccak256, numberToHex, toBytes } from \"viem\";\n\n// TODO: move to protocol-parser?\n// equivalent of StoreCore._getStaticDataLocation\n\nconst SLOT = hexToBigInt(keccak256(toBytes(\"mud.store\")));\n\nexport function getStaticDataLocation(tableId: Hex, keyTuple: readonly Hex[]): Hex {\n  return numberToHex(SLOT ^ hexToBigInt(keccak256(concatHex([tableId, ...keyTuple]))), { size: 32 });\n}\n"],"mappings":"+bAkBO,IAAMA,EAAc,CACzB,WAAY,KACZ,eAAgB,KAChB,YAAa,IACf,ECtBA,OAQE,mBAAAC,EAGA,eAAAC,EACA,aAAAC,EACA,kBAAAC,MACK,OCdP,OAAOC,MAAiB,QAEjB,IAAMC,EAAQD,EAAY,WAAW,EAC5CC,EAAM,IAAM,QAAQ,MAAM,KAAK,OAAO,EAE/B,IAAMC,EAAQF,EAAY,WAAW,EAC5CE,EAAM,IAAM,QAAQ,MAAM,KAAK,OAAO,EDWtC,OAAS,iBAAAC,EAAe,mBAAAC,MAAuB,qBA0C/C,eAAsBC,GAIpBC,EACA,CAAE,QAAAC,EAAS,QAAAC,EAAS,UAAAC,EAAW,QAAAC,CAAQ,EAAgD,CAAC,EACnC,CASrD,IAAMC,EAAqB,CAACC,EAAe,IAAIC,CAAe,EAAGL,GAAW,IAAI,EAE1EM,EAAWN,EAAW,MAAM,QAAQA,CAAO,EAAIA,EAAU,CAACA,CAAO,EAAK,CAAC,EACvEO,EAAYR,EAAW,MAAM,QAAQA,CAAO,EAAIA,EAAU,CAACA,CAAO,EAAK,CAAC,EAC9ES,EACE,0BACEF,EAAS,OAASA,EAAS,IAAIX,CAAa,EAAE,IAAIC,CAAe,EAAE,KAAK,IAAI,EAAI,YAClF,OAAOW,EAAU,OAASA,EAAU,KAAK,IAAI,EAAI,aAAa,EAChE,EAcA,IAAME,GAZiB,MAAMX,EAAO,QAAQ,CAC1C,OAAQ,cACR,OAAQ,CACN,CACE,QAAAC,EACA,OAAAI,EACA,UAAW,OAAOF,GAAc,SAAWS,EAAYT,CAAS,EAAIA,EACpE,QAAS,OAAOC,GAAY,SAAWQ,EAAYR,CAAO,EAAIA,CAChE,CACF,CACF,CAAC,GAE0B,IAAKS,GAAQC,EAAUD,CAAG,CAAC,EACtD,OAAOE,EAAe,CACpB,IAAKT,EACL,KAAM,CAAE,QAAAJ,CAAQ,EAChB,KAAMS,EACN,OAAQ,EACV,CAAC,CACH,CEvGA,OAAc,QAAAK,MAAY,OAI1B,OAAS,WAAAC,EAAS,aAAAC,MAAiB,qBAEnC,SAASC,EAAOC,EAA+E,CAC7F,MAAO,CAACA,EAAI,QAASA,EAAI,KAAK,QAASA,EAAI,KAAK,SAAS,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,CAC9E,CAEO,SAASC,GAAiBC,EAAuC,CACtE,IAAMC,EAAaD,EAAK,MAAM,EAAE,KAAKL,CAAO,EACtCO,EAAU,IAAI,IAEpB,QAAWJ,KAAOG,EAAY,CAC5B,IAAME,EAAMN,EAAOC,CAAG,EAEtB,GAAIA,EAAI,YAAc,kBAGpBI,EAAQ,OAAOC,CAAG,EAClBD,EAAQ,IAAIC,EAAKL,CAAG,UACXA,EAAI,YAAc,yBAA0B,CACrD,IAAMM,EAAiBF,EAAQ,IAAIC,CAAG,EAChC,CAAE,WAAAE,EAAY,eAAAC,EAAgB,YAAAC,CAAY,EAAIH,GAAgB,MAAQI,EACtEC,EAAa,CACjB,GAAGX,EACH,UAAW,kBACX,KAAM,CACJ,QAASA,EAAI,KAAK,QAClB,SAAUA,EAAI,KAAK,SACnB,WAAYF,EAAUS,EAAYP,EAAI,KAAK,MAAOY,EAAKZ,EAAI,KAAK,IAAI,EAAGA,EAAI,KAAK,IAAI,EACpF,eAAAQ,EACA,YAAAC,CACF,CACF,EAGAL,EAAQ,OAAOC,CAAG,EAClBD,EAAQ,IAAIC,EAAKM,CAAU,CAC7B,SAAWX,EAAI,YAAc,0BAA2B,CACtD,IAAMM,EAAiBF,EAAQ,IAAIC,CAAG,EAChC,CAAE,WAAAE,EAAY,YAAAE,CAAY,EAAIH,GAAgB,MAAQI,EACtDC,EAAa,CACjB,GAAGX,EACH,UAAW,kBACX,KAAM,CACJ,QAASA,EAAI,KAAK,QAClB,SAAUA,EAAI,KAAK,SACnB,WAAAO,EACA,eAAgBP,EAAI,KAAK,eACzB,YAAaF,EAAUW,EAAaT,EAAI,KAAK,MAAOA,EAAI,KAAK,YAAaA,EAAI,KAAK,IAAI,CACzF,CACF,EAGAI,EAAQ,OAAOC,CAAG,EAClBD,EAAQ,IAAIC,EAAKM,CAAU,CAC7B,MAAWX,EAAI,YAAc,sBAC3BI,EAAQ,OAAOC,CAAG,CAEtB,CAEA,OAAO,MAAM,KAAKD,EAAQ,OAAO,CAAC,CACpC,CC/DA,OACE,aAAAS,EACA,mBAAAC,EACA,gBAAAC,EAEA,kBAAAC,EACA,kBAAAC,MACK,uCAWA,SAASC,GAAwC,CACtD,MAAAC,EACA,IAAAC,CACF,EAAiE,CAC/D,IAAMC,EAAYL,EAAeD,EAAaI,CAAK,CAAC,EAC9CG,EAAcN,EAAeC,EAAeE,CAAK,CAAC,EAClDI,EAAMV,EAAUQ,EAAWD,EAAI,KAAK,QAAQ,EAC5CI,EAAQV,EAAgBQ,EAAaF,EAAI,IAAI,EACnD,MAAO,CAAE,GAAGG,EAAK,GAAGC,CAAM,CAC5B,CC1BA,OACE,mBAAAC,EAEA,eAAAC,EAEA,kBAAAC,EACA,kBAAAC,MACK,uCACP,OAAS,gBAAAC,MAAoB,eAC7B,OAAS,aAAAC,MAAiB,aAS1B,eAAsBC,GACpBC,EACA,CAAE,QAAAC,EAAS,MAAAC,EAAO,IAAAC,EAAK,SAAAC,CAAS,EACe,CAC/C,GAAM,CAACC,EAAYC,EAAgBC,CAAW,EAAI,MAAMT,EACtDE,EACAH,EACA,cACF,EAAE,CACA,QAAAI,EACA,IAAAO,EACA,aAAc,YACd,KAAM,CAACN,EAAM,QAASR,EAAYQ,EAAOC,CAAG,CAAmB,EAC/D,SAAAC,CACF,CAAC,EAED,MAAO,CACL,GAAGD,EACH,GAAGV,EAAgBE,EAAeC,EAAeM,CAAK,CAAC,EAAG,CAAE,WAAAG,EAAY,eAAAC,EAAgB,YAAAC,CAAY,CAAC,CACvG,CACF,CAEA,IAAMC,EAAM,CACV,CACE,KAAM,WACN,KAAM,YACN,OAAQ,CACN,CACE,KAAM,UACN,KAAM,UACN,aAAc,YAChB,EACA,CACE,KAAM,WACN,KAAM,YACN,aAAc,WAChB,CACF,EACA,QAAS,CACP,CACE,KAAM,aACN,KAAM,QACN,aAAc,OAChB,EACA,CACE,KAAM,iBACN,KAAM,UACN,aAAc,gBAChB,EACA,CACE,KAAM,cACN,KAAM,QACN,aAAc,OAChB,CACF,EACA,gBAAiB,MACnB,CACF,EC7EA,OAAc,aAAAC,EAAW,eAAAC,EAAa,aAAAC,EAAW,eAAAC,EAAa,WAAAC,MAAe,OAK7E,IAAMC,EAAOJ,EAAYC,EAAUE,EAAQ,WAAW,CAAC,CAAC,EAEjD,SAASE,GAAsBC,EAAcC,EAA+B,CACjF,OAAOL,EAAYE,EAAOJ,EAAYC,EAAUF,EAAU,CAACO,EAAS,GAAGC,CAAQ,CAAC,CAAC,CAAC,EAAG,CAAE,KAAM,EAAG,CAAC,CACnG","names":["emptyRecord","toEventSelector","numberToHex","formatLog","parseEventLogs","createDebug","debug","error","hexToResource","resourceToLabel","getStoreLogs","client","address","tableId","fromBlock","toBlock","topics","storeEventsAbi","toEventSelector","tableIds","addresses","debug","formattedLogs","numberToHex","log","formatLog","parseEventLogs","size","logSort","spliceHex","getKey","log","flattenStoreLogs","logs","sortedLogs","records","key","previousRecord","staticData","encodedLengths","dynamicData","emptyRecord","nextRecord","size","decodeKey","decodeValueArgs","getKeySchema","getSchemaTypes","getValueSchema","logToRecord","table","log","keySchema","valueSchema","key","value","decodeValueArgs","getKeyTuple","getSchemaTypes","getValueSchema","readContract","getAction","getRecord","client","address","table","key","blockTag","staticData","encodedLengths","dynamicData","abi","concatHex","hexToBigInt","keccak256","numberToHex","toBytes","SLOT","getStaticDataLocation","tableId","keyTuple"]}
+{"version":3,"sources":["../ts/common.ts","../ts/getStoreLogs.ts","../ts/debug.ts","../ts/flattenStoreLogs.ts","../ts/logToRecord.ts","../ts/getRecord.ts","../ts/getStaticDataLocation.ts"],"sourcesContent":["import { SchemaAbiType, SchemaAbiTypeToPrimitiveType, StaticAbiType } from \"@latticexyz/schema-type/internal\";\n\nexport type KeySchema = {\n  readonly [k: string]: {\n    readonly type: StaticAbiType;\n  };\n};\nexport type ValueSchema = {\n  readonly [k: string]: {\n    readonly type: SchemaAbiType;\n  };\n};\n\n/** Map a table schema like `{ value: { type: \"uint256\" } }` to its primitive types like `{ value: bigint }` */\nexport type SchemaToPrimitives<schema extends ValueSchema> = {\n  readonly [key in keyof schema]: SchemaAbiTypeToPrimitiveType<schema[key][\"type\"]>;\n};\n\nexport const emptyRecord = {\n  staticData: \"0x\",\n  encodedLengths: \"0x\",\n  dynamicData: \"0x\",\n} as const;\n","import {\n  BlockNumber,\n  BlockTag,\n  Address,\n  Log,\n  Hex,\n  GetLogsErrorType,\n  Client,\n  toEventSelector,\n  LogTopic,\n  RpcLog,\n  numberToHex,\n  formatLog,\n  parseEventLogs,\n} from \"viem\";\nimport { storeEventsAbi } from \"./storeEventsAbi\";\nimport { debug } from \"./debug\";\nimport { hexToResource, resourceToLabel } from \"@latticexyz/common\";\n\nexport type GetStoreLogsParameters<\n  fromBlock extends BlockNumber | BlockTag | undefined = undefined,\n  toBlock extends BlockNumber | BlockTag | undefined = undefined,\n> = {\n  /** Store address or list of store addresses from which logs originated */\n  address?: Address | Address[] | undefined;\n  /** Optionally match a specific table ID or list of table IDs */\n  tableId?: Hex | Hex[] | undefined;\n  /** Block number or tag after which to include logs */\n  fromBlock?: fromBlock | BlockNumber | BlockTag | undefined;\n  /** Block number or tag before which to include logs */\n  toBlock?: toBlock | BlockNumber | BlockTag | undefined;\n};\n\nexport type GetStoreLogsReturnType<\n  fromBlock extends BlockNumber | BlockTag | undefined = undefined,\n  toBlock extends BlockNumber | BlockTag | undefined = undefined,\n  _pending extends boolean = (fromBlock extends \"pending\" ? true : false) | (toBlock extends \"pending\" ? true : false),\n> = Log<bigint, number, _pending, undefined, true, storeEventsAbi, undefined>[];\n\nexport type GetStoreLogsErrorType = GetLogsErrorType;\n\n/**\n * Returns an unordered list of store event logs matching the provided parameters.\n *\n * @param client - Client to use\n * @param parameters - {@link GetStoreLogsParameters}\n * @returns A list of event logs. {@link GetStoreLogsReturnType}\n *\n * @example\n * import { createClient, http } from 'viem'\n * import { mainnet } from 'viem/chains'\n * import { getStoreLogs } from '@latticexyz/store'\n *\n * const client = createPublicClient({\n *   chain: mainnet,\n *   transport: http(),\n * })\n * const storeLogs = await getStoreLogs(client)\n */\nexport async function getStoreLogs<\n  fromBlock extends BlockNumber | BlockTag | undefined = undefined,\n  toBlock extends BlockNumber | BlockTag | undefined = undefined,\n>(\n  client: Client,\n  { address, tableId, fromBlock, toBlock }: GetStoreLogsParameters<fromBlock, toBlock> = {},\n): Promise<GetStoreLogsReturnType<fromBlock, toBlock>> {\n  /**\n   * Note that this implementation follows Viem's [`getLogs`][0] action:\n   * https://github.com/wevm/viem/blob/main/src/actions/public/getLogs.ts\n   *\n   * It's adapted to allow filtering by table ID(s), which Viem's `getLogs`\n   * does not support due to how it builds topics.\n   */\n\n  const topics: LogTopic[] = [storeEventsAbi.map(toEventSelector), tableId ?? null];\n\n  const tableIds = tableId ? (Array.isArray(tableId) ? tableId : [tableId]) : [];\n  const addresses = address ? (Array.isArray(address) ? address : [address]) : [];\n  debug(\n    `getting store logs for ${\n      tableIds.length ? tableIds.map(hexToResource).map(resourceToLabel).join(\", \") : \"all tables\"\n    } at ${addresses.length ? addresses.join(\", \") : \"any address\"}`,\n  );\n\n  const logs: RpcLog[] = await client.request({\n    method: \"eth_getLogs\",\n    params: [\n      {\n        address,\n        topics,\n        fromBlock: typeof fromBlock === \"bigint\" ? numberToHex(fromBlock) : fromBlock,\n        toBlock: typeof toBlock === \"bigint\" ? numberToHex(toBlock) : toBlock,\n      },\n    ],\n  });\n\n  const formattedLogs = logs.map((log) => formatLog(log));\n  return parseEventLogs({\n    abi: storeEventsAbi,\n    args: { tableId },\n    logs: formattedLogs,\n    strict: true,\n  }) as GetStoreLogsReturnType<fromBlock, toBlock>;\n}\n","import createDebug from \"debug\";\n\nexport const debug = createDebug(\"mud:store\");\ndebug.log = console.debug.bind(console);\n\nexport const error = createDebug(\"mud:store\");\nerror.log = console.error.bind(console);\n","import { Log, size } from \"viem\";\nimport { storeEventsAbi } from \"./storeEventsAbi\";\nimport { emptyRecord } from \"./common\";\nimport { StoreLog, StoreSetRecordLog } from \"./storeLog\";\nimport { logSort, spliceHex } from \"@latticexyz/common\";\n\nfunction getKey(log: Log<bigint, number, boolean, undefined, true, storeEventsAbi, undefined>) {\n  return [log.address, log.args.tableId, log.args.keyTuple.join(\",\")].join(\":\");\n}\n\nexport function flattenStoreLogs(logs: StoreLog[]): StoreSetRecordLog[] {\n  const sortedLogs = logs.slice().sort(logSort);\n  const records = new Map<string, StoreSetRecordLog>();\n\n  for (const log of sortedLogs) {\n    const key = getKey(log);\n\n    if (log.eventName === \"Store_SetRecord\") {\n      // maps preserve order, so always delete then set so the record gets\n      // added to the end of the map, thus preserving the log order\n      records.delete(key);\n      records.set(key, log);\n    } else if (log.eventName === \"Store_SpliceStaticData\") {\n      const previousRecord = records.get(key);\n      const { staticData, encodedLengths, dynamicData } = previousRecord?.args ?? emptyRecord;\n      const nextRecord = {\n        ...log,\n        eventName: \"Store_SetRecord\",\n        args: {\n          tableId: log.args.tableId,\n          keyTuple: log.args.keyTuple,\n          staticData: spliceHex(staticData, log.args.start, size(log.args.data), log.args.data),\n          encodedLengths,\n          dynamicData,\n        },\n      } satisfies StoreSetRecordLog;\n      // maps preserve order, so always delete then set so the record gets\n      // added to the end of the map, thus preserving the log order\n      records.delete(key);\n      records.set(key, nextRecord);\n    } else if (log.eventName === \"Store_SpliceDynamicData\") {\n      const previousRecord = records.get(key);\n      const { staticData, dynamicData } = previousRecord?.args ?? emptyRecord;\n      const nextRecord = {\n        ...log,\n        eventName: \"Store_SetRecord\",\n        args: {\n          tableId: log.args.tableId,\n          keyTuple: log.args.keyTuple,\n          staticData,\n          encodedLengths: log.args.encodedLengths,\n          dynamicData: spliceHex(dynamicData, log.args.start, log.args.deleteCount, log.args.data),\n        },\n      } satisfies StoreSetRecordLog;\n      // maps preserve order, so always delete then set so the record gets\n      // added to the end of the map, thus preserving the log order\n      records.delete(key);\n      records.set(key, nextRecord);\n    } else if (log.eventName === \"Store_DeleteRecord\") {\n      records.delete(key);\n    }\n  }\n\n  return Array.from(records.values());\n}\n","import { Table } from \"@latticexyz/config\";\nimport {\n  decodeKey,\n  decodeValueArgs,\n  getKeySchema,\n  getSchemaPrimitives,\n  getSchemaTypes,\n  getValueSchema,\n} from \"@latticexyz/protocol-parser/internal\";\nimport { StoreLog } from \"./storeLog\";\n\ntype PartialTable = Pick<Table, \"schema\" | \"key\">;\ntype PartialLog = Pick<Extract<StoreLog, { eventName: \"Store_SetRecord\" }>, \"args\">;\n\nexport type LogToRecordArgs<table extends PartialTable> = {\n  table: table;\n  log: PartialLog;\n};\n\nexport function logToRecord<table extends PartialTable>({\n  table,\n  log,\n}: LogToRecordArgs<table>): getSchemaPrimitives<table[\"schema\"]> {\n  const keySchema = getSchemaTypes(getKeySchema(table));\n  const valueSchema = getSchemaTypes(getValueSchema(table));\n  const key = decodeKey(keySchema, log.args.keyTuple);\n  const value = decodeValueArgs(valueSchema, log.args);\n  return { ...key, ...value };\n}\n","import { Address, Client, Hex } from \"viem\";\nimport { Table } from \"@latticexyz/config\";\nimport {\n  decodeValueArgs,\n  getKeySchema,\n  getKeyTuple,\n  getSchemaPrimitives,\n  getSchemaTypes,\n  getValueSchema,\n} from \"@latticexyz/protocol-parser/internal\";\nimport { readContract } from \"viem/actions\";\nimport { getAction } from \"viem/utils\";\n\nexport type GetRecordOptions<table extends Table> = {\n  address: Address;\n  table: table;\n  key: getSchemaPrimitives<getKeySchema<table>>;\n  blockTag?: \"latest\" | \"pending\";\n};\n\nexport async function getRecord<table extends Table>(\n  client: Client,\n  { address, table, key, blockTag }: GetRecordOptions<table>,\n): Promise<getSchemaPrimitives<table[\"schema\"]>> {\n  const [staticData, encodedLengths, dynamicData] = await getAction(\n    client,\n    readContract,\n    \"readContract\",\n  )({\n    address,\n    abi,\n    functionName: \"getRecord\",\n    args: [table.tableId, getKeyTuple(table, key) as readonly Hex[]],\n    blockTag,\n  });\n\n  return {\n    ...key,\n    ...decodeValueArgs(getSchemaTypes(getValueSchema(table)), { staticData, encodedLengths, dynamicData }),\n  };\n}\n\nconst 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] as const;\n","import { Hex, concatHex, hexToBigInt, keccak256, numberToHex, toBytes } from \"viem\";\n\n// TODO: move to protocol-parser?\n// equivalent of StoreCore._getStaticDataLocation\n\nconst SLOT = hexToBigInt(keccak256(toBytes(\"mud.store\")));\n\nexport function getStaticDataLocation(tableId: Hex, keyTuple: readonly Hex[]): Hex {\n  return numberToHex(SLOT ^ hexToBigInt(keccak256(concatHex([tableId, ...keyTuple]))), { size: 32 });\n}\n"],"mappings":"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","names":["decodeValueArgs","getSchemaTypes","getValueSchema","numberToHex"]}

package/dist/mud.config.js

@@ -1,2 +1,61 @@
-import{V as e}from"./chunk-5YJ4WITG.js";var o=e({namespace:"store",codegen:{storeImportPath:"./src"},userTypes:{ResourceId:{filePath:"./src/ResourceId.sol",type:"bytes32"},FieldLayout:{filePath:"./src/FieldLayout.sol",type:"bytes32"},Schema:{filePath:"./src/Schema.sol",type:"bytes32"}},tables:{StoreHooks:{schema:{tableId:"ResourceId",hooks:"bytes21[]"},key:["tableId"]},Tables:{schema:{tableId:"ResourceId",fieldLayout:"FieldLayout",keySchema:"Schema",valueSchema:"Schema",abiEncodedKeyNames:"bytes",abiEncodedFieldNames:"bytes"},key:["tableId"]},ResourceIds:{schema:{resourceId:"ResourceId",exists:"bool"},key:["resourceId"]},Hooks:{schema:{resourceId:"ResourceId",hooks:"bytes21[]"},key:["resourceId"],codegen:{tableIdArgument:!0},deploy:{disabled:!0}}}});export{o as default};
+import {
+  defineStore
+} from "./chunk-FULF4J63.js";
+
+// mud.config.ts
+var mud_config_default = defineStore({
+  namespace: "store",
+  codegen: {
+    storeImportPath: "./src"
+  },
+  userTypes: {
+    ResourceId: { filePath: "./src/ResourceId.sol", type: "bytes32" },
+    FieldLayout: { filePath: "./src/FieldLayout.sol", type: "bytes32" },
+    Schema: { filePath: "./src/Schema.sol", type: "bytes32" }
+  },
+  tables: {
+    StoreHooks: {
+      schema: {
+        tableId: "ResourceId",
+        hooks: "bytes21[]"
+      },
+      key: ["tableId"]
+    },
+    Tables: {
+      schema: {
+        tableId: "ResourceId",
+        fieldLayout: "FieldLayout",
+        keySchema: "Schema",
+        valueSchema: "Schema",
+        abiEncodedKeyNames: "bytes",
+        abiEncodedFieldNames: "bytes"
+      },
+      key: ["tableId"]
+    },
+    ResourceIds: {
+      schema: {
+        resourceId: "ResourceId",
+        exists: "bool"
+      },
+      key: ["resourceId"]
+    },
+    // This is generic, codegen-only table used by `filterFromList` in `Hook.sol`
+    Hooks: {
+      schema: {
+        resourceId: "ResourceId",
+        hooks: "bytes21[]"
+      },
+      key: ["resourceId"],
+      codegen: {
+        tableIdArgument: true
+      },
+      deploy: {
+        disabled: true
+      }
+    }
+  }
+});
+export {
+  mud_config_default as default
+};
 //# sourceMappingURL=mud.config.js.map

package/dist/mud.config.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../mud.config.ts"],"sourcesContent":["import { defineStore } from \"./ts/config/v2/store\";\n\nexport default defineStore({\n  namespace: \"store\",\n  codegen: {\n    storeImportPath: \"./src\",\n  },\n  userTypes: {\n    ResourceId: { filePath: \"./src/ResourceId.sol\", type: \"bytes32\" },\n    FieldLayout: { filePath: \"./src/FieldLayout.sol\", type: \"bytes32\" },\n    Schema: { filePath: \"./src/Schema.sol\", type: \"bytes32\" },\n  },\n  tables: {\n    StoreHooks: {\n      schema: {\n        tableId: \"ResourceId\",\n        hooks: \"bytes21[]\",\n      },\n      key: [\"tableId\"],\n    },\n    Tables: {\n      schema: {\n        tableId: \"ResourceId\",\n        fieldLayout: \"FieldLayout\",\n        keySchema: \"Schema\",\n        valueSchema: \"Schema\",\n        abiEncodedKeyNames: \"bytes\",\n        abiEncodedFieldNames: \"bytes\",\n      },\n      key: [\"tableId\"],\n    },\n    ResourceIds: {\n      schema: {\n        resourceId: \"ResourceId\",\n        exists: \"bool\",\n      },\n      key: [\"resourceId\"],\n    },\n    // This is generic, codegen-only table used by `filterFromList` in `Hook.sol`\n    Hooks: {\n      schema: {\n        resourceId: \"ResourceId\",\n        hooks: \"bytes21[]\",\n      },\n      key: [\"resourceId\"],\n      codegen: {\n        tableIdArgument: true,\n      },\n      deploy: {\n        disabled: true,\n      },\n    },\n  },\n});\n"],"mappings":"wCAEA,IAAOA,EAAQC,EAAY,CACzB,UAAW,QACX,QAAS,CACP,gBAAiB,OACnB,EACA,UAAW,CACT,WAAY,CAAE,SAAU,uBAAwB,KAAM,SAAU,EAChE,YAAa,CAAE,SAAU,wBAAyB,KAAM,SAAU,EAClE,OAAQ,CAAE,SAAU,mBAAoB,KAAM,SAAU,CAC1D,EACA,OAAQ,CACN,WAAY,CACV,OAAQ,CACN,QAAS,aACT,MAAO,WACT,EACA,IAAK,CAAC,SAAS,CACjB,EACA,OAAQ,CACN,OAAQ,CACN,QAAS,aACT,YAAa,cACb,UAAW,SACX,YAAa,SACb,mBAAoB,QACpB,qBAAsB,OACxB,EACA,IAAK,CAAC,SAAS,CACjB,EACA,YAAa,CACX,OAAQ,CACN,WAAY,aACZ,OAAQ,MACV,EACA,IAAK,CAAC,YAAY,CACpB,EAEA,MAAO,CACL,OAAQ,CACN,WAAY,aACZ,MAAO,WACT,EACA,IAAK,CAAC,YAAY,EAClB,QAAS,CACP,gBAAiB,EACnB,EACA,OAAQ,CACN,SAAU,EACZ,CACF,CACF,CACF,CAAC","names":["mud_config_default","defineStore"]}
+{"version":3,"sources":["../mud.config.ts"],"sourcesContent":["import { defineStore } from \"./ts/config/v2/store\";\n\nexport default defineStore({\n  namespace: \"store\",\n  codegen: {\n    storeImportPath: \"./src\",\n  },\n  userTypes: {\n    ResourceId: { filePath: \"./src/ResourceId.sol\", type: \"bytes32\" },\n    FieldLayout: { filePath: \"./src/FieldLayout.sol\", type: \"bytes32\" },\n    Schema: { filePath: \"./src/Schema.sol\", type: \"bytes32\" },\n  },\n  tables: {\n    StoreHooks: {\n      schema: {\n        tableId: \"ResourceId\",\n        hooks: \"bytes21[]\",\n      },\n      key: [\"tableId\"],\n    },\n    Tables: {\n      schema: {\n        tableId: \"ResourceId\",\n        fieldLayout: \"FieldLayout\",\n        keySchema: \"Schema\",\n        valueSchema: \"Schema\",\n        abiEncodedKeyNames: \"bytes\",\n        abiEncodedFieldNames: \"bytes\",\n      },\n      key: [\"tableId\"],\n    },\n    ResourceIds: {\n      schema: {\n        resourceId: \"ResourceId\",\n        exists: \"bool\",\n      },\n      key: [\"resourceId\"],\n    },\n    // This is generic, codegen-only table used by `filterFromList` in `Hook.sol`\n    Hooks: {\n      schema: {\n        resourceId: \"ResourceId\",\n        hooks: \"bytes21[]\",\n      },\n      key: [\"resourceId\"],\n      codegen: {\n        tableIdArgument: true,\n      },\n      deploy: {\n        disabled: true,\n      },\n    },\n  },\n});\n"],"mappings":";;;;;AAEA,IAAO,qBAAQ,YAAY;AAAA,EACzB,WAAW;AAAA,EACX,SAAS;AAAA,IACP,iBAAiB;AAAA,EACnB;AAAA,EACA,WAAW;AAAA,IACT,YAAY,EAAE,UAAU,wBAAwB,MAAM,UAAU;AAAA,IAChE,aAAa,EAAE,UAAU,yBAAyB,MAAM,UAAU;AAAA,IAClE,QAAQ,EAAE,UAAU,oBAAoB,MAAM,UAAU;AAAA,EAC1D;AAAA,EACA,QAAQ;AAAA,IACN,YAAY;AAAA,MACV,QAAQ;AAAA,QACN,SAAS;AAAA,QACT,OAAO;AAAA,MACT;AAAA,MACA,KAAK,CAAC,SAAS;AAAA,IACjB;AAAA,IACA,QAAQ;AAAA,MACN,QAAQ;AAAA,QACN,SAAS;AAAA,QACT,aAAa;AAAA,QACb,WAAW;AAAA,QACX,aAAa;AAAA,QACb,oBAAoB;AAAA,QACpB,sBAAsB;AAAA,MACxB;AAAA,MACA,KAAK,CAAC,SAAS;AAAA,IACjB;AAAA,IACA,aAAa;AAAA,MACX,QAAQ;AAAA,QACN,YAAY;AAAA,QACZ,QAAQ;AAAA,MACV;AAAA,MACA,KAAK,CAAC,YAAY;AAAA,IACpB;AAAA;AAAA,IAEA,OAAO;AAAA,MACL,QAAQ;AAAA,QACN,YAAY;AAAA,QACZ,OAAO;AAAA,MACT;AAAA,MACA,KAAK,CAAC,YAAY;AAAA,MAClB,SAAS;AAAA,QACP,iBAAiB;AAAA,MACnB;AAAA,MACA,QAAQ;AAAA,QACN,UAAU;AAAA,MACZ;AAAA,IACF;AAAA,EACF;AACF,CAAC;","names":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@latticexyz/store",
-  "version": "2.2.18-ebe1aea8d4afb690ce1c7c2bcb42dc0f1faf6e77",
+  "version": "2.2.18",
   "description": "Store",
   "repository": {
     "type": "git",
@@ -42,10 +42,10 @@
     "abitype": "1.0.6",
     "arktype": "2.0.0-beta.6",
     "debug": "^4.3.4",
-    "@latticexyz/common": "2.2.18-ebe1aea8d4afb690ce1c7c2bcb42dc0f1faf6e77",
-    "@latticexyz/config": "2.2.18-ebe1aea8d4afb690ce1c7c2bcb42dc0f1faf6e77",
-    "@latticexyz/protocol-parser": "2.2.18-ebe1aea8d4afb690ce1c7c2bcb42dc0f1faf6e77",
-    "@latticexyz/schema-type": "2.2.18-ebe1aea8d4afb690ce1c7c2bcb42dc0f1faf6e77"
+    "@latticexyz/common": "2.2.18",
+    "@latticexyz/config": "2.2.18",
+    "@latticexyz/protocol-parser": "2.2.18",
+    "@latticexyz/schema-type": "2.2.18"
   },
   "devDependencies": {
     "@types/debug": "^4.1.7",
@@ -54,8 +54,8 @@
     "forge-std": "https://github.com/foundry-rs/forge-std.git#74cfb77e308dd188d2f58864aaf44963ae6b88b1",
     "solhint": "^3.3.7",
     "viem": "2.21.19",
-    "@latticexyz/abi-ts": "2.2.18-ebe1aea8d4afb690ce1c7c2bcb42dc0f1faf6e77",
-    "@latticexyz/gas-report": "2.2.18-ebe1aea8d4afb690ce1c7c2bcb42dc0f1faf6e77"
+    "@latticexyz/abi-ts": "2.2.18",
+    "@latticexyz/gas-report": "2.2.18"
   },
   "peerDependencies": {
     "viem": "2.x"

package/dist/chunk-4TACS4IT.js

@@ -1,2 +0,0 @@
-var i="event HelloStore(bytes32 indexed storeVersion)",t="event Store_SetRecord(bytes32 indexed tableId, bytes32[] keyTuple, bytes staticData, bytes32 encodedLengths, bytes dynamicData)",o="event Store_SpliceStaticData(bytes32 indexed tableId, bytes32[] keyTuple, uint48 start, bytes data)",s="event Store_SpliceDynamicData(bytes32 indexed tableId, bytes32[] keyTuple, uint8 dynamicFieldIndex, uint48 start, uint40 deleteCount, bytes32 encodedLengths, bytes data)",n="event Store_DeleteRecord(bytes32 indexed tableId, bytes32[] keyTuple)",e=[t,o,s,n];import{parseAbi as r}from"abitype";var p=r(e);export{i as a,t as b,o as c,s as d,n as e,e as f,p as g};
-//# sourceMappingURL=chunk-4TACS4IT.js.map

package/dist/chunk-5YJ4WITG.js

@@ -1,2 +0,0 @@
-function c(e,t){return typeof e=="object"&&e!=null&&o(e,t)?e[t]:void 0}function V(e,t){return t.length?V(c(e,t[0]),t.slice(1)):e}function o(e,t){return typeof e=="object"&&e!==null&&e.hasOwnProperty(t)}function r(e){return e!=null&&typeof e=="object"}function i(e,t){let s=[...new Set([...Object.keys(e),...Object.keys(t)])];return Object.fromEntries(s.map(n=>[n,typeof e[n]>"u"?t[n]:e[n]]))}var b={storeImportPath:"@latticexyz/store/src",userTypesFilename:"common.sol",outputDirectory:"codegen",indexFilename:"index.sol"},d={outputDirectory:"tables",tableIdArgument:!1,storeArgument:!1},O={disabled:!1},x={namespaceLabel:"",type:"table"},T={sourceDirectory:"src",namespace:""};import{schemaAbiTypes as W}from"@latticexyz/schema-type/internal";var de={types:{}},a={types:Object.fromEntries(W.map(e=>[e,e]))};function u(e,t){return{types:{...e.types,...t}}}import{fixedArrayToArray as J,isFixedArrayAbiType as S}from"@latticexyz/schema-type/internal";function h(e,t=a){if(!r(e))throw new Error(`Expected schema, received ${JSON.stringify(e)}`);for(let s of Object.values(e))if(!S(s)&&!o(t.types,s))throw new Error(`"${String(s)}" is not a valid type in this scope.`)}function k(e,t=a){return Object.fromEntries(Object.entries(e).map(([s,n])=>[s,{type:S(n)?J(n):t.types[n],internalType:n}]))}function he(e,t=a){return h(e,t),k(e,t)}function v(e,t=a){return typeof e=="object"&&e!=null&&Object.values(e).every(s=>S(s)||o(t.types,s))}import{isStaticAbiType as L}from"@latticexyz/schema-type/internal";import{resourceToHex as Y}from"@latticexyz/common";function q(e,t=a){return Object.entries(e).filter(([,s])=>o(t.types,s)&&L(t.types[s])).map(([s])=>s)}function H(e,t,s=a){return Array.isArray(e)&&e.every(n=>o(t,n)&&o(s.types,t[n])&&L(s.types[t[n]]))}function g(e,t=a,s={inStoreContext:!1}){if(typeof e!="object"||e==null)throw new Error(`Expected full table config, got \`${JSON.stringify(e)}\``);if(!o(e,"schema"))throw new Error("Missing schema input");if(h(e.schema,t),!o(e,"key")||!H(e.key,e.schema,t))throw new Error(`Invalid key. Expected \`(${q(e.schema,t).map(n=>`"${String(n)}"`).join(" | ")})[]\`, received \`${o(e,"key")&&Array.isArray(e.key)?`[${e.key.map(n=>`"${n}"`).join(", ")}]`:String(c(e,"key"))}\``);if(o(e,"namespace")&&typeof e.namespace=="string"&&e.namespace.length>14)throw new Error(`Table \`namespace\` must fit into a \`bytes14\`, but "${e.namespace}" is too long.`);if(o(e,"namespaceLabel")&&typeof e.namespaceLabel=="string"&&(!o(e,"namespace")||typeof e.namespace!="string")&&e.namespaceLabel.length>14)throw new Error(`Table \`namespace\` defaults to \`namespaceLabel\`, but must fit into a \`bytes14\` and "${e.namespaceLabel}" is too long. Provide explicit \`namespace\` override.`);if(o(e,"name")&&typeof e.name=="string"&&e.name.length>16)throw new Error(`Table \`name\` must fit into a \`bytes16\`, but "${e.name}" is too long.`);if(s.inStoreContext&&(o(e,"label")||o(e,"namespaceLabel")||o(e,"namespace")))throw new Error("Overrides of `label`, `namespaceLabel`, and `namespace` are not allowed for tables in this context.")}function R(e){let t=e.codegen;return{outputDirectory:c(t,"outputDirectory")??d.outputDirectory,tableIdArgument:c(t,"tableIdArgument")??d.tableIdArgument,storeArgument:c(t,"storeArgument")??d.storeArgument,dataStruct:c(t,"dataStruct")??Object.keys(e.schema).length-e.key.length>1}}function E(e,t=a){let s=e.namespaceLabel??x.namespaceLabel,n=e.namespace??s,p=e.label,y=e.name??p.slice(0,16),N=e.type??x.type,P=Y({type:N,namespace:n,name:y});return{label:p,type:N,namespace:n,namespaceLabel:s,name:y,tableId:P,schema:k(e.schema,t),key:e.key,codegen:R(e),deploy:i(e.deploy??{},O)}}function Le(e,t=a){return g(e,t),E(e,t)}import{isFixedArrayAbiType as z,isStaticAbiType as Q}from"@latticexyz/schema-type/internal";var Be="Invalid schema. Expected an `id` field with a static ABI type or an explicit `key` option.";function D(e){return typeof e=="string"||r(e)&&Object.values(e).every(t=>typeof t=="string")}function A(e,t=a){if(typeof e=="string"){if(z(e)||o(t.types,e))return;throw new Error(`Invalid ABI type. \`${e}\` not found in scope.`)}if(typeof e=="object"&&e!==null){if(v(e,t)){if(o(e,"id")&&Q(t.types[e.id]))return;throw new Error("Invalid schema. Expected an `id` field with a static ABI type or an explicit `key` option.")}throw new Error("Invalid schema. Are you using invalid types or missing types in your scope?")}throw new Error("Invalid table shorthand.")}function l(e,t){return typeof e=="string"?{schema:{id:"bytes32",value:e},key:["id"]}:v(e,t)?{schema:e,key:["id"]}:e}function Ge(e,t=a){return A(e,t),l(e,t)}function m(e,t){if(r(e)){for(let s of Object.values(e))D(s)?A(s,t):g(s,t,{inStoreContext:!0});return}throw new Error(`Expected tables config, received ${JSON.stringify(e)}`)}function I(e,t){return Object.fromEntries(Object.entries(e).map(([s,n])=>[s,E(i(l(n,t),{label:s}),t)]))}function qe(e,t=a){return m(e,t),I(e,t)}import{mapObject as X}from"@latticexyz/common/utils";import{isSchemaAbiType as Z}from"@latticexyz/schema-type/internal";function ee(e){return X(e,t=>t.type)}function te(e){return r(e)&&Object.values(e).every(t=>Z(t.type))}function U(e,t=a){return te(e)?u(t,ee(e)):t}function F(e){if(!r(e))throw new Error(`Expected userTypes, received ${JSON.stringify(e)}`);for(let{type:t}of Object.values(e))if(!o(a.types,t))throw new Error(`"${String(t)}" is not a valid ABI type.`)}import{flatMorph as _}from"@ark/util";function se(e){return typeof e=="object"&&e!=null&&Object.values(e).every(t=>Array.isArray(t)&&t.every(s=>typeof s=="string"))}function j(e,t=a){if(se(e)){let s=Object.fromEntries(Object.keys(e).map(n=>[n,"uint8"]));return u(t,s)}return t}function ne(e){return e}function C(e){return _(e,(t,s)=>[t,_(s,(n,p)=>[p,n])])}function K(e){return r(e)?i(e,b):b}import{flatMorph as oe}from"@ark/util";function $(e,t){if(o(e,"namespace")&&typeof e.namespace=="string"&&e.namespace.length>14)throw new Error(`\`namespace\` must fit into a \`bytes14\`, but "${e.namespace}" is too long.`);o(e,"tables")&&m(e.tables,t)}function B(e,t=a){let s=e.label,n=e.namespace??s.slice(0,14);return{label:s,namespace:n,tables:I(oe(e.tables??{},(p,y)=>[p,i(l(y,t),{namespace:n,namespaceLabel:s})]),t)}}import{flatMorph as ae}from"@ark/util";import{groupBy as pe}from"@latticexyz/common/utils";function w(e,t){if(!r(e))throw new Error(`Expected namespaces, received ${JSON.stringify(e)}`);for(let s of Object.values(e))$(s,t)}function f(e,t){if(!r(e))throw new Error(`Expected namespaces config, received ${JSON.stringify(e)}`);let s=ae(e,(p,y)=>[p,B(i(y,{label:p}),t)]),n=Array.from(pe(Object.values(s),p=>p.namespace).entries()).filter(([,p])=>p.length>1).map(([p])=>p);if(n.length>0)throw new Error(`Found namespaces defined more than once in config: ${n.join(", ")}`);return s}function vt(e,t=a){return w(e,t),f(e,t)}function G(e){return Object.fromEntries(Object.entries(e.namespaces).flatMap(([t,s])=>Object.entries(s.tables).map(([n,p])=>[t===""?n:`${t}__${n}`,p])))}function M(e){return j(c(e,"enums"),U(c(e,"userTypes")))}function re(e){let t=M(e);if(o(e,"namespaces")){if(o(e,"namespace")||o(e,"tables"))throw new Error("Cannot use `namespaces` with `namespace` or `tables` keys.");w(e.namespaces,t)}if(o(e,"namespace")&&typeof e.namespace=="string"&&e.namespace.length>14)throw new Error(`\`namespace\` must fit into a \`bytes14\`, but "${e.namespace}" is too long.`);o(e,"tables")&&m(e.tables,t),o(e,"userTypes")&&F(e.userTypes)}function ce(e){let t=M(e),s=e.namespace??T.namespace,n=e.namespaces?{multipleNamespaces:!0,namespace:null,namespaces:f(e.namespaces,t)}:{multipleNamespaces:!1,namespace:s,namespaces:f({[s]:e},t)},p=G(n);return{...n,tables:p,sourceDirectory:e.sourceDirectory??T.sourceDirectory,userTypes:e.userTypes??{},enums:e.enums??{},enumValues:C(e.enums??{}),codegen:K(e.codegen)}}function Ft(e){return re(e),ce(e)}export{c as a,V as b,o as c,r as d,i as e,b as f,d as g,O as h,x as i,T as j,de as k,a as l,u as m,h as n,k as o,he as p,v as q,H as r,g as s,R as t,E as u,Le as v,Be as w,D as x,A as y,l as z,Ge as A,m as B,I as C,qe as D,ee as E,te as F,U as G,F as H,j as I,ne as J,C as K,K as L,$ as M,B as N,w as O,f as P,vt as Q,G as R,M as S,re as T,ce as U,Ft as V};
-//# sourceMappingURL=chunk-5YJ4WITG.js.map