@latticexyz/protocol-parser 2.0.0-main-3042f86e → 2.0.0-main-db314a74

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (27) hide show
  1. package/dist/index.js.map +1 -1
  2. package/package.json +3 -3
  3. package/src/decodeDynamicField.test.ts +26 -26
  4. package/src/decodeDynamicField.ts +1 -1
  5. package/src/decodeField.ts +1 -1
  6. package/src/decodeKey.ts +2 -2
  7. package/src/decodeKeyTuple.test.ts +3 -3
  8. package/src/decodeKeyTuple.ts +2 -2
  9. package/src/decodeRecord.test.ts +1 -1
  10. package/src/decodeRecord.ts +2 -2
  11. package/src/decodeStaticField.test.ts +16 -16
  12. package/src/decodeStaticField.ts +1 -1
  13. package/src/decodeValue.ts +1 -1
  14. package/src/decodeValueArgs.ts +2 -2
  15. package/src/encodeField.ts +2 -2
  16. package/src/encodeKeyTuple.test.ts +3 -3
  17. package/src/encodeLengths.test.ts +2 -2
  18. package/src/encodeLengths.ts +1 -1
  19. package/src/encodeRecord.test.ts +1 -1
  20. package/src/encodeRecord.ts +2 -2
  21. package/src/encodeValue.ts +1 -1
  22. package/src/encodeValueArgs.ts +2 -2
  23. package/src/errors.ts +4 -4
  24. package/src/hexToPackedCounter.test.ts +3 -3
  25. package/src/hexToSchema.test.ts +2 -2
  26. package/src/hexToSchema.ts +1 -1
  27. package/src/schemaToHex.test.ts +3 -3
package/dist/index.js.map CHANGED
@@ -1 +1 @@
1
- {"version":3,"sources":["../src/abiTypesToSchema.ts","../src/decodeDynamicField.ts","../src/decodeStaticField.ts","../src/errors.ts","../src/decodeField.ts","../src/decodeKeyTuple.ts","../src/decodeKey.ts","../src/decodeRecord.ts","../src/hexToPackedCounter.ts","../src/staticDataLength.ts","../src/decodeValue.ts","../src/decodeValueArgs.ts","../src/encodeField.ts","../src/encodeKey.ts","../src/encodeKeyTuple.ts","../src/encodeRecord.ts","../src/encodeValue.ts","../src/encodeValueArgs.ts","../src/encodeLengths.ts","../src/fieldLayoutToHex.ts","../src/hexToSchema.ts","../src/hexToTableSchema.ts","../src/keySchemaToHex.ts","../src/schemaToHex.ts","../src/schemaIndexToAbiType.ts","../src/valueSchemaToFieldLayoutHex.ts","../src/valueSchemaToHex.ts"],"sourcesContent":["import { DynamicAbiType, SchemaAbiType, StaticAbiType, isDynamicAbiType } from \"@latticexyz/schema-type\";\nimport { Schema } from \"./common\";\n\nexport function abiTypesToSchema(abiTypes: SchemaAbiType[]): Schema {\n const staticFields: StaticAbiType[] = [];\n const dynamicFields: DynamicAbiType[] = [];\n for (const abiType of abiTypes) {\n if (isDynamicAbiType(abiType)) dynamicFields.push(abiType);\n else staticFields.push(abiType);\n }\n return { staticFields, dynamicFields };\n}\n","import { Hex, hexToString, sliceHex } from \"viem\";\nimport { assertExhaustive } from \"@latticexyz/common/utils\";\nimport {\n DynamicAbiType,\n DynamicAbiTypeToPrimitiveType,\n arrayAbiTypeToStaticAbiType,\n staticAbiTypeToByteLength,\n} from \"@latticexyz/schema-type\";\nimport { decodeStaticField } from \"./decodeStaticField\";\nimport { InvalidHexLengthError, InvalidHexLengthForArrayFieldError } from \"./errors\";\n\n// TODO: require size/length for dynamic fields, because hex might be longer (sometimes we just move the length pointer of arrays without updating the value)\n// this means the error should probably change from \"invalid length\" to \"too short\", which viem has that we could reuse?\n\nexport function decodeDynamicField<\n TAbiType extends DynamicAbiType,\n TPrimitiveType extends DynamicAbiTypeToPrimitiveType<TAbiType>\n>(abiType: TAbiType, data: Hex): TPrimitiveType {\n if (abiType === \"bytes\") {\n return data as TPrimitiveType;\n }\n if (abiType === \"string\") {\n return hexToString(data) as TPrimitiveType;\n }\n\n if (data.length > 3 && data.length % 2 !== 0) {\n throw new InvalidHexLengthError(data);\n }\n\n const dataSize = (data.length - 2) / 2;\n\n switch (abiType) {\n case \"uint8[]\":\n case \"uint16[]\":\n case \"uint24[]\":\n case \"uint32[]\":\n case \"uint40[]\":\n case \"uint48[]\":\n case \"uint56[]\":\n case \"uint64[]\":\n case \"uint72[]\":\n case \"uint80[]\":\n case \"uint88[]\":\n case \"uint96[]\":\n case \"uint104[]\":\n case \"uint112[]\":\n case \"uint120[]\":\n case \"uint128[]\":\n case \"uint136[]\":\n case \"uint144[]\":\n case \"uint152[]\":\n case \"uint160[]\":\n case \"uint168[]\":\n case \"uint176[]\":\n case \"uint184[]\":\n case \"uint192[]\":\n case \"uint200[]\":\n case \"uint208[]\":\n case \"uint216[]\":\n case \"uint224[]\":\n case \"uint232[]\":\n case \"uint240[]\":\n case \"uint248[]\":\n case \"uint256[]\":\n case \"int8[]\":\n case \"int16[]\":\n case \"int24[]\":\n case \"int32[]\":\n case \"int40[]\":\n case \"int48[]\":\n case \"int56[]\":\n case \"int64[]\":\n case \"int72[]\":\n case \"int80[]\":\n case \"int88[]\":\n case \"int96[]\":\n case \"int104[]\":\n case \"int112[]\":\n case \"int120[]\":\n case \"int128[]\":\n case \"int136[]\":\n case \"int144[]\":\n case \"int152[]\":\n case \"int160[]\":\n case \"int168[]\":\n case \"int176[]\":\n case \"int184[]\":\n case \"int192[]\":\n case \"int200[]\":\n case \"int208[]\":\n case \"int216[]\":\n case \"int224[]\":\n case \"int232[]\":\n case \"int240[]\":\n case \"int248[]\":\n case \"int256[]\":\n case \"bytes1[]\":\n case \"bytes2[]\":\n case \"bytes3[]\":\n case \"bytes4[]\":\n case \"bytes5[]\":\n case \"bytes6[]\":\n case \"bytes7[]\":\n case \"bytes8[]\":\n case \"bytes9[]\":\n case \"bytes10[]\":\n case \"bytes11[]\":\n case \"bytes12[]\":\n case \"bytes13[]\":\n case \"bytes14[]\":\n case \"bytes15[]\":\n case \"bytes16[]\":\n case \"bytes17[]\":\n case \"bytes18[]\":\n case \"bytes19[]\":\n case \"bytes20[]\":\n case \"bytes21[]\":\n case \"bytes22[]\":\n case \"bytes23[]\":\n case \"bytes24[]\":\n case \"bytes25[]\":\n case \"bytes26[]\":\n case \"bytes27[]\":\n case \"bytes28[]\":\n case \"bytes29[]\":\n case \"bytes30[]\":\n case \"bytes31[]\":\n case \"bytes32[]\":\n case \"bool[]\":\n case \"address[]\": {\n const staticAbiType = arrayAbiTypeToStaticAbiType(abiType);\n const itemByteLength = staticAbiTypeToByteLength[staticAbiType];\n if (dataSize % itemByteLength !== 0) {\n throw new InvalidHexLengthForArrayFieldError(staticAbiType, data);\n }\n const items = new Array(dataSize / itemByteLength).fill(undefined).map((_, i) => {\n const itemData = sliceHex(data, i * itemByteLength, (i + 1) * itemByteLength);\n return decodeStaticField(staticAbiType, itemData);\n });\n return items as TPrimitiveType;\n }\n }\n\n return assertExhaustive(abiType, `Unsupported dynamic ABI type: ${abiType}`);\n}\n","import { Hex, getAddress, hexToBigInt, hexToBool } from \"viem\";\nimport { assertExhaustive } from \"@latticexyz/common/utils\";\nimport {\n StaticAbiType,\n StaticAbiTypeToPrimitiveType,\n staticAbiTypeToByteLength,\n staticAbiTypeToDefaultValue,\n} from \"@latticexyz/schema-type\";\nimport { InvalidHexLengthError, InvalidHexLengthForStaticFieldError } from \"./errors\";\n\nexport function decodeStaticField<\n TAbiType extends StaticAbiType,\n TPrimitiveType extends StaticAbiTypeToPrimitiveType<TAbiType>\n>(abiType: TAbiType, data: Hex): TPrimitiveType {\n if (data.length > 3 && data.length % 2 !== 0) {\n throw new InvalidHexLengthError(data);\n }\n\n const dataSize = (data.length - 2) / 2;\n if (dataSize !== staticAbiTypeToByteLength[abiType]) {\n throw new InvalidHexLengthForStaticFieldError(abiType, data);\n }\n\n switch (abiType) {\n case \"uint8\":\n case \"uint16\":\n case \"uint24\":\n case \"uint32\":\n case \"uint40\":\n case \"uint48\":\n case \"uint56\":\n case \"uint64\":\n case \"uint72\":\n case \"uint80\":\n case \"uint88\":\n case \"uint96\":\n case \"uint104\":\n case \"uint112\":\n case \"uint120\":\n case \"uint128\":\n case \"uint136\":\n case \"uint144\":\n case \"uint152\":\n case \"uint160\":\n case \"uint168\":\n case \"uint176\":\n case \"uint184\":\n case \"uint192\":\n case \"uint200\":\n case \"uint208\":\n case \"uint216\":\n case \"uint224\":\n case \"uint232\":\n case \"uint240\":\n case \"uint248\":\n case \"uint256\":\n case \"int8\":\n case \"int16\":\n case \"int24\":\n case \"int32\":\n case \"int40\":\n case \"int48\":\n case \"int56\":\n case \"int64\":\n case \"int72\":\n case \"int80\":\n case \"int88\":\n case \"int96\":\n case \"int104\":\n case \"int112\":\n case \"int120\":\n case \"int128\":\n case \"int136\":\n case \"int144\":\n case \"int152\":\n case \"int160\":\n case \"int168\":\n case \"int176\":\n case \"int184\":\n case \"int192\":\n case \"int200\":\n case \"int208\":\n case \"int216\":\n case \"int224\":\n case \"int232\":\n case \"int240\":\n case \"int248\":\n case \"int256\": {\n const value = hexToBigInt(data, { signed: abiType.startsWith(\"int\") });\n const defaultValueType = typeof staticAbiTypeToDefaultValue[abiType];\n if (defaultValueType === \"number\") {\n return Number(value) as TPrimitiveType;\n }\n if (defaultValueType === \"bigint\") {\n return value as TPrimitiveType;\n }\n throw new Error(`Unexpected default value type (${defaultValueType}) for ABI type (${abiType})`);\n }\n\n case \"bytes1\":\n case \"bytes2\":\n case \"bytes3\":\n case \"bytes4\":\n case \"bytes5\":\n case \"bytes6\":\n case \"bytes7\":\n case \"bytes8\":\n case \"bytes9\":\n case \"bytes10\":\n case \"bytes11\":\n case \"bytes12\":\n case \"bytes13\":\n case \"bytes14\":\n case \"bytes15\":\n case \"bytes16\":\n case \"bytes17\":\n case \"bytes18\":\n case \"bytes19\":\n case \"bytes20\":\n case \"bytes21\":\n case \"bytes22\":\n case \"bytes23\":\n case \"bytes24\":\n case \"bytes25\":\n case \"bytes26\":\n case \"bytes27\":\n case \"bytes28\":\n case \"bytes29\":\n case \"bytes30\":\n case \"bytes31\":\n case \"bytes32\": {\n return data as TPrimitiveType;\n }\n\n case \"bool\": {\n return hexToBool(data) as TPrimitiveType;\n }\n\n case \"address\": {\n return getAddress(data) as TPrimitiveType;\n }\n }\n\n return assertExhaustive(abiType, `Unsupported static ABI type: ${abiType}`);\n}\n","import { Hex } from \"viem\";\nimport { MUDError } from \"@latticexyz/common/errors\";\nimport { StaticAbiType, staticAbiTypeToByteLength } from \"@latticexyz/schema-type\";\n\nexport class InvalidHexLengthError extends MUDError {\n override name = \"InvalidHexValueError\";\n constructor(value: Hex) {\n super(`Hex value \"${value}\" is an odd length (${value.length - 2}). It must be an even length.`);\n }\n}\n\nexport class InvalidHexLengthForSchemaError extends MUDError {\n override name = \"InvalidHexLengthForSchemaError\";\n constructor(value: Hex) {\n super(`Hex value \"${value}\" has length of ${value.length - 2}, but expected length of 64 for a schema.`);\n }\n}\n\nexport class InvalidHexLengthForPackedCounterError extends MUDError {\n override name = \"InvalidHexLengthForPackedCounterError\";\n constructor(value: Hex) {\n super(`Hex value \"${value}\" has length of ${value.length - 2}, but expected length of 64 for a packed counter.`);\n }\n}\n\nexport class InvalidHexLengthForStaticFieldError extends MUDError {\n override name = \"InvalidHexLengthForStaticFieldError\";\n constructor(abiType: StaticAbiType, value: Hex) {\n super(\n `Hex value \"${value}\" has length of ${value.length - 2}, but expected length of ${\n staticAbiTypeToByteLength[abiType] * 2\n } for ${abiType} type.`\n );\n }\n}\n\nexport class InvalidHexLengthForArrayFieldError extends MUDError {\n override name = \"InvalidHexLengthForArrayFieldError\";\n constructor(abiType: StaticAbiType, value: Hex) {\n super(\n `Hex value \"${value}\" has length of ${value.length - 2}, but expected a multiple of ${\n staticAbiTypeToByteLength[abiType] * 2\n } for ${abiType}[] type.`\n );\n }\n}\n\nexport class SchemaStaticLengthMismatchError extends MUDError {\n override name = \"SchemaStaticLengthMismatchError\";\n constructor(schemaData: Hex, definedLength: number, summedLength: number) {\n super(\n `Schema \"${schemaData}\" static data length (${definedLength}) did not match the summed length of all static fields (${summedLength}). ` +\n `Is \\`staticAbiTypeToByteLength\\` up to date with Solidity schema types?`\n );\n }\n}\n\nexport class PackedCounterLengthMismatchError extends MUDError {\n override name = \"PackedCounterLengthMismatchError\";\n constructor(packedCounterData: Hex, definedLength: bigint, summedLength: bigint) {\n super(\n `PackedCounter \"${packedCounterData}\" total bytes length (${definedLength}) did not match the summed length of all field byte lengths (${summedLength}).`\n );\n }\n}\n","import { Hex } from \"viem\";\nimport { SchemaAbiType, SchemaAbiTypeToPrimitiveType, isDynamicAbiType } from \"@latticexyz/schema-type\";\nimport { decodeDynamicField } from \"./decodeDynamicField\";\nimport { decodeStaticField } from \"./decodeStaticField\";\n\nexport function decodeField<\n TAbiType extends SchemaAbiType,\n TPrimitiveType extends SchemaAbiTypeToPrimitiveType<TAbiType>\n>(abiType: TAbiType, data: Hex): TPrimitiveType {\n return (\n isDynamicAbiType(abiType) ? decodeDynamicField(abiType, data) : decodeStaticField(abiType, data)\n ) as TPrimitiveType;\n}\n","import { Hex, decodeAbiParameters } from \"viem\";\nimport { StaticPrimitiveType } from \"@latticexyz/schema-type\";\nimport { Schema } from \"./common\";\n\n// key tuples are encoded in the same way as abi.encode, so we can decode them with viem\n\n/** @deprecated use `decodeKey` instead */\nexport function decodeKeyTuple(keySchema: Schema, keyTuple: readonly Hex[]): StaticPrimitiveType[] {\n if (keySchema.staticFields.length !== keyTuple.length) {\n throw new Error(\n `key tuple length ${keyTuple.length} does not match key schema length ${keySchema.staticFields.length}`\n );\n }\n return keyTuple.map(\n (key, index) => decodeAbiParameters([{ type: keySchema.staticFields[index] }], key)[0] as StaticPrimitiveType\n );\n}\n","import { Hex } from \"viem\";\nimport { SchemaToPrimitives, KeySchema } from \"./common\";\nimport { decodeKeyTuple } from \"./decodeKeyTuple\";\n\nexport function decodeKey<TSchema extends KeySchema>(\n keySchema: TSchema,\n data: readonly Hex[]\n): SchemaToPrimitives<TSchema> {\n // TODO: refactor and move all decodeKeyTuple logic into this method so we can delete decodeKeyTuple\n const keyValues = decodeKeyTuple({ staticFields: Object.values(keySchema), dynamicFields: [] }, data);\n\n return Object.fromEntries(\n Object.keys(keySchema).map((name, i) => [name, keyValues[i]])\n ) as SchemaToPrimitives<TSchema>;\n}\n","import {\n StaticPrimitiveType,\n DynamicPrimitiveType,\n staticAbiTypeToByteLength,\n dynamicAbiTypeToDefaultValue,\n} from \"@latticexyz/schema-type\";\nimport { Hex } from \"viem\";\nimport { Schema } from \"./common\";\nimport { decodeDynamicField } from \"./decodeDynamicField\";\nimport { decodeStaticField } from \"./decodeStaticField\";\nimport { hexToPackedCounter } from \"./hexToPackedCounter\";\nimport { staticDataLength } from \"./staticDataLength\";\nimport { readHex } from \"@latticexyz/common\";\n\n/** @deprecated use `decodeValue` instead */\nexport function decodeRecord(valueSchema: Schema, data: Hex): readonly (StaticPrimitiveType | DynamicPrimitiveType)[] {\n const values: (StaticPrimitiveType | DynamicPrimitiveType)[] = [];\n\n let bytesOffset = 0;\n valueSchema.staticFields.forEach((fieldType) => {\n const fieldByteLength = staticAbiTypeToByteLength[fieldType];\n const value = decodeStaticField(fieldType, readHex(data, bytesOffset, bytesOffset + fieldByteLength));\n bytesOffset += fieldByteLength;\n values.push(value);\n });\n\n // Warn user if static data length doesn't match the value schema, because data corruption might be possible.\n const schemaStaticDataLength = staticDataLength(valueSchema.staticFields);\n const actualStaticDataLength = bytesOffset;\n if (actualStaticDataLength !== schemaStaticDataLength) {\n console.warn(\n \"Decoded static data length does not match value schema's expected static data length. Data may get corrupted. Is `getStaticByteLength` outdated?\",\n {\n expectedLength: schemaStaticDataLength,\n actualLength: actualStaticDataLength,\n bytesOffset,\n }\n );\n }\n\n if (valueSchema.dynamicFields.length > 0) {\n const dataLayout = hexToPackedCounter(readHex(data, bytesOffset, bytesOffset + 32));\n bytesOffset += 32;\n\n valueSchema.dynamicFields.forEach((fieldType, i) => {\n const dataLength = dataLayout.fieldByteLengths[i];\n if (dataLength > 0) {\n const value = decodeDynamicField(fieldType, readHex(data, bytesOffset, bytesOffset + dataLength));\n bytesOffset += dataLength;\n values.push(value);\n } else {\n values.push(dynamicAbiTypeToDefaultValue[fieldType]);\n }\n });\n\n // Warn user if dynamic data length doesn't match the dynamic data length, because data corruption might be possible.\n const actualDynamicDataLength = bytesOffset - 32 - actualStaticDataLength;\n // TODO: refactor this so we don't break for bytes offsets >UINT40\n if (BigInt(actualDynamicDataLength) !== dataLayout.totalByteLength) {\n console.warn(\n \"Decoded dynamic data length does not match data layout's expected data length. Data may get corrupted. Did the data layout change?\",\n {\n expectedLength: dataLayout.totalByteLength,\n actualLength: actualDynamicDataLength,\n bytesOffset,\n }\n );\n }\n }\n\n return values;\n}\n","import { Hex } from \"viem\";\nimport { decodeStaticField } from \"./decodeStaticField\";\nimport { decodeDynamicField } from \"./decodeDynamicField\";\nimport { InvalidHexLengthForPackedCounterError, PackedCounterLengthMismatchError } from \"./errors\";\nimport { readHex } from \"@latticexyz/common\";\n\n// Keep this logic in sync with PackedCounter.sol\n\n// - Last 7 bytes (uint56) are used for the total byte length of the dynamic data\n// - The next 5 byte (uint40) sections are used for the byte length of each field, indexed from right to left\n\n// We use byte lengths rather than item counts so that, on chain, we can slice without having to get the value schema first (and thus the field lengths of each dynamic type)\n\nexport function hexToPackedCounter(data: Hex): {\n totalByteLength: bigint;\n fieldByteLengths: readonly number[];\n} {\n if (data.length !== 66) {\n throw new InvalidHexLengthForPackedCounterError(data);\n }\n\n const totalByteLength = decodeStaticField(\"uint56\", readHex(data, 32 - 7, 32));\n // TODO: use value schema to make sure we only parse as many as we need (rather than zeroes at the end)?\n const reversedFieldByteLengths = decodeDynamicField(\"uint40[]\", readHex(data, 0, 32 - 7));\n // Reverse the lengths\n const fieldByteLengths = Object.freeze([...reversedFieldByteLengths].reverse());\n\n const summedLength = BigInt(fieldByteLengths.reduce((total, length) => total + length, 0));\n if (summedLength !== totalByteLength) {\n throw new PackedCounterLengthMismatchError(data, totalByteLength, summedLength);\n }\n\n return { totalByteLength, fieldByteLengths };\n}\n","import { StaticAbiType, staticAbiTypeToByteLength } from \"@latticexyz/schema-type\";\n\nexport function staticDataLength(staticFields: readonly StaticAbiType[]): number {\n return staticFields.reduce((length, fieldType) => length + staticAbiTypeToByteLength[fieldType], 0);\n}\n","import { isStaticAbiType, isDynamicAbiType } from \"@latticexyz/schema-type\";\nimport { Hex } from \"viem\";\nimport { SchemaToPrimitives, ValueSchema } from \"./common\";\nimport { decodeRecord } from \"./decodeRecord\";\n\nexport function decodeValue<TSchema extends ValueSchema>(valueSchema: TSchema, data: Hex): SchemaToPrimitives<TSchema> {\n const staticFields = Object.values(valueSchema).filter(isStaticAbiType);\n const dynamicFields = Object.values(valueSchema).filter(isDynamicAbiType);\n\n // TODO: refactor and move all decodeRecord logic into this method so we can delete decodeRecord\n const valueTuple = decodeRecord({ staticFields, dynamicFields }, data);\n\n return Object.fromEntries(\n Object.keys(valueSchema).map((name, i) => [name, valueTuple[i]])\n ) as SchemaToPrimitives<TSchema>;\n}\n","import { concatHex } from \"viem\";\nimport { isStaticAbiType } from \"@latticexyz/schema-type\";\nimport { SchemaToPrimitives, ValueArgs, ValueSchema } from \"./common\";\nimport { decodeValue } from \"./decodeValue\";\nimport { staticDataLength } from \"./staticDataLength\";\nimport { readHex } from \"@latticexyz/common\";\n\nexport function decodeValueArgs<TSchema extends ValueSchema>(\n valueSchema: TSchema,\n { staticData, encodedLengths, dynamicData }: ValueArgs\n): SchemaToPrimitives<TSchema> {\n return decodeValue(\n valueSchema,\n concatHex([\n readHex(staticData, 0, staticDataLength(Object.values(valueSchema).filter(isStaticAbiType))),\n encodedLengths,\n dynamicData,\n ])\n );\n}\n","import { SchemaAbiType, arrayAbiTypeToStaticAbiType, isArrayAbiType } from \"@latticexyz/schema-type\";\nimport { AbiParameterToPrimitiveType } from \"abitype\";\nimport { Hex, encodePacked } from \"viem\";\n\nexport function encodeField<TSchemaAbiType extends SchemaAbiType>(\n fieldType: TSchemaAbiType,\n value: AbiParameterToPrimitiveType<{ type: TSchemaAbiType }>\n): Hex {\n if (isArrayAbiType(fieldType) && Array.isArray(value)) {\n const staticFieldType = arrayAbiTypeToStaticAbiType(fieldType);\n // TODO: we can remove conditional once this is fixed: https://github.com/wagmi-dev/viem/pull/1147\n return value.length === 0\n ? \"0x\"\n : encodePacked(\n value.map(() => staticFieldType),\n value\n );\n }\n return encodePacked([fieldType], [value]);\n}\n","import { isStaticAbiType } from \"@latticexyz/schema-type\";\nimport { Hex } from \"viem\";\nimport { SchemaToPrimitives, KeySchema } from \"./common\";\nimport { encodeKeyTuple } from \"./encodeKeyTuple\";\n\nexport function encodeKey<TSchema extends KeySchema>(keySchema: TSchema, key: SchemaToPrimitives<TSchema>): Hex[] {\n const staticFields = Object.values(keySchema).filter(isStaticAbiType);\n // TODO: refactor and move all encodeKeyTuple logic into this method so we can delete encodeKeyTuple\n return encodeKeyTuple({ staticFields, dynamicFields: [] }, Object.values(key));\n}\n","import { StaticPrimitiveType } from \"@latticexyz/schema-type\";\nimport { Hex, encodeAbiParameters } from \"viem\";\nimport { Schema } from \"./common\";\n\n/** @deprecated use `encodeKey` instead */\nexport function encodeKeyTuple(keySchema: Schema, keyTuple: StaticPrimitiveType[]): Hex[] {\n return keyTuple.map((key, index) => encodeAbiParameters([{ type: keySchema.staticFields[index] }], [key]));\n}\n","import { StaticPrimitiveType, DynamicPrimitiveType } from \"@latticexyz/schema-type\";\nimport { Hex } from \"viem\";\nimport { encodeField } from \"./encodeField\";\nimport { Schema } from \"./common\";\n\n/** @deprecated use `encodeValue` instead */\nexport function encodeRecord(\n valueSchema: Schema,\n values: readonly (StaticPrimitiveType | DynamicPrimitiveType)[]\n): Hex {\n const staticValues = values.slice(0, valueSchema.staticFields.length) as readonly StaticPrimitiveType[];\n const dynamicValues = values.slice(valueSchema.staticFields.length) as readonly DynamicPrimitiveType[];\n\n const staticData = staticValues\n .map((value, i) => encodeField(valueSchema.staticFields[i], value).replace(/^0x/, \"\"))\n .join(\"\");\n\n if (valueSchema.dynamicFields.length === 0) return `0x${staticData}`;\n\n const dynamicDataItems = dynamicValues.map((value, i) =>\n encodeField(valueSchema.dynamicFields[i], value).replace(/^0x/, \"\")\n );\n\n const dynamicFieldByteLengths = dynamicDataItems.map((value) => value.length / 2).reverse();\n const dynamicTotalByteLength = dynamicFieldByteLengths.reduce((total, length) => total + BigInt(length), 0n);\n\n const dynamicData = dynamicDataItems.join(\"\");\n\n const packedCounter = `${dynamicFieldByteLengths\n .map((length) => encodeField(\"uint40\", length).replace(/^0x/, \"\"))\n .join(\"\")}${encodeField(\"uint56\", dynamicTotalByteLength).replace(/^0x/, \"\")}`.padStart(64, \"0\");\n\n return `0x${staticData}${packedCounter}${dynamicData}`;\n}\n","import { Hex, concatHex } from \"viem\";\nimport { SchemaToPrimitives, ValueSchema } from \"./common\";\nimport { encodeValueArgs } from \"./encodeValueArgs\";\n\nexport function encodeValue<TSchema extends ValueSchema>(\n valueSchema: TSchema,\n value: SchemaToPrimitives<TSchema>\n): Hex {\n const { staticData, encodedLengths, dynamicData } = encodeValueArgs(valueSchema, value);\n return concatHex([staticData, encodedLengths, dynamicData]);\n}\n","import {\n StaticPrimitiveType,\n DynamicPrimitiveType,\n isStaticAbiType,\n isDynamicAbiType,\n StaticAbiType,\n DynamicAbiType,\n} from \"@latticexyz/schema-type\";\nimport { concatHex } from \"viem\";\nimport { encodeField } from \"./encodeField\";\nimport { SchemaToPrimitives, ValueArgs, ValueSchema } from \"./common\";\nimport { encodeLengths } from \"./encodeLengths\";\n\nexport function encodeValueArgs<TSchema extends ValueSchema>(\n valueSchema: TSchema,\n value: SchemaToPrimitives<TSchema>\n): ValueArgs {\n const valueSchemaEntries = Object.entries(valueSchema);\n const staticFields = valueSchemaEntries.filter(([, type]) => isStaticAbiType(type)) as [string, StaticAbiType][];\n const dynamicFields = valueSchemaEntries.filter(([, type]) => isDynamicAbiType(type)) as [string, DynamicAbiType][];\n // TODO: validate <=5 dynamic fields\n // TODO: validate <=28 total fields\n\n const encodedStaticValues = staticFields.map(([name, type]) => encodeField(type, value[name] as StaticPrimitiveType));\n const encodedDynamicValues = dynamicFields.map(([name, type]) =>\n encodeField(type, value[name] as DynamicPrimitiveType)\n );\n\n const encodedLengths = encodeLengths(encodedDynamicValues);\n\n return {\n staticData: concatHex(encodedStaticValues),\n encodedLengths,\n dynamicData: concatHex(encodedDynamicValues),\n };\n}\n","import { Hex, concatHex, padHex, size } from \"viem\";\nimport { encodeField } from \"./encodeField\";\n\nexport function encodeLengths(values: Hex[]): Hex {\n const byteLengths = values.map(size).reverse();\n const totalByteLength = byteLengths.reduce((total, length) => total + BigInt(length), 0n);\n\n return padHex(\n concatHex([...byteLengths.map((length) => encodeField(\"uint40\", length)), encodeField(\"uint56\", totalByteLength)]),\n { size: 32, dir: \"left\" }\n );\n}\n","import { Hex } from \"viem\";\nimport { FieldLayout } from \"./common\";\n\n/** @deprecated use `valueSchemaToFieldLayoutHex` instead */\nexport function fieldLayoutToHex(fieldLayout: FieldLayout): Hex {\n const staticDataLength = fieldLayout.staticFieldLengths.reduce((totalLength, length) => totalLength + length, 0);\n return `0x${[\n staticDataLength.toString(16).padStart(4, \"0\"),\n fieldLayout.staticFieldLengths.length.toString(16).padStart(2, \"0\"),\n fieldLayout.numDynamicFields.toString(16).padStart(2, \"0\"),\n ...fieldLayout.staticFieldLengths.map((schemaType) => schemaType.toString(16).padStart(2, \"0\")),\n ]\n .join(\"\")\n .padEnd(64, \"0\")}`;\n}\n","import { StaticAbiType, DynamicAbiType, schemaAbiTypes, staticAbiTypeToByteLength } from \"@latticexyz/schema-type\";\nimport { Hex, hexToNumber, sliceHex } from \"viem\";\nimport { Schema } from \"./common\";\nimport { InvalidHexLengthForSchemaError, SchemaStaticLengthMismatchError } from \"./errors\";\n\nexport function hexToSchema(data: Hex): Schema {\n if (data.length !== 66) {\n throw new InvalidHexLengthForSchemaError(data);\n }\n\n const staticDataLength = hexToNumber(sliceHex(data, 0, 2));\n const numStaticFields = hexToNumber(sliceHex(data, 2, 3));\n const numDynamicFields = hexToNumber(sliceHex(data, 3, 4));\n const staticFields: StaticAbiType[] = [];\n const dynamicFields: DynamicAbiType[] = [];\n\n for (let i = 4; i < 4 + numStaticFields; i++) {\n const schemaTypeIndex = hexToNumber(sliceHex(data, i, i + 1));\n staticFields.push(schemaAbiTypes[schemaTypeIndex] as StaticAbiType);\n }\n for (let i = 4 + numStaticFields; i < 4 + numStaticFields + numDynamicFields; i++) {\n const schemaTypeIndex = hexToNumber(sliceHex(data, i, i + 1));\n dynamicFields.push(schemaAbiTypes[schemaTypeIndex] as DynamicAbiType);\n }\n\n // validate static data length\n const actualStaticDataLength = staticFields.reduce((acc, fieldType) => acc + staticAbiTypeToByteLength[fieldType], 0);\n if (actualStaticDataLength !== staticDataLength) {\n console.warn(\n `Schema \"${data}\" static data length (${staticDataLength}) did not match the summed length of all static fields (${actualStaticDataLength}). ` +\n `Is \\`staticAbiTypeToByteLength\\` up to date with Solidity schema types?`\n );\n throw new SchemaStaticLengthMismatchError(data, staticDataLength, actualStaticDataLength);\n }\n\n return { staticFields, dynamicFields };\n}\n","import { Hex, sliceHex } from \"viem\";\nimport { TableSchema } from \"./common\";\nimport { hexToSchema } from \"./hexToSchema\";\n\nexport function hexToTableSchema(data: Hex): TableSchema {\n const valueSchema = hexToSchema(sliceHex(data, 0, 32));\n const keySchema = hexToSchema(sliceHex(data, 32, 64));\n return {\n keySchema,\n valueSchema,\n };\n}\n","import { isStaticAbiType } from \"@latticexyz/schema-type\";\nimport { Hex } from \"viem\";\nimport { KeySchema } from \"./common\";\nimport { schemaToHex } from \"./schemaToHex\";\n\nexport function keySchemaToHex(keySchema: KeySchema): Hex {\n return schemaToHex({ staticFields: Object.values(keySchema).filter(isStaticAbiType), dynamicFields: [] });\n}\n","import { schemaAbiTypes } from \"@latticexyz/schema-type\";\nimport { Hex } from \"viem\";\nimport { Schema } from \"./common\";\nimport { staticDataLength } from \"./staticDataLength\";\n\n/** @deprecated use `keySchemaToHex` or `valueSchemaToHex` instead */\nexport function schemaToHex(schema: Schema): Hex {\n const staticSchemaTypes = schema.staticFields.map((abiType) => schemaAbiTypes.indexOf(abiType));\n const dynamicSchemaTypes = schema.dynamicFields.map((abiType) => schemaAbiTypes.indexOf(abiType));\n return `0x${[\n staticDataLength(schema.staticFields).toString(16).padStart(4, \"0\"),\n schema.staticFields.length.toString(16).padStart(2, \"0\"),\n schema.dynamicFields.length.toString(16).padStart(2, \"0\"),\n ...staticSchemaTypes.map((schemaType) => schemaType.toString(16).padStart(2, \"0\")),\n ...dynamicSchemaTypes.map((schemaType) => schemaType.toString(16).padStart(2, \"0\")),\n ]\n .join(\"\")\n .padEnd(64, \"0\")}`;\n}\n","import { SchemaAbiType } from \"@latticexyz/schema-type\";\nimport { Schema } from \"./common\";\n\nexport function schemaIndexToAbiType(schema: Schema, schemaIndex: number): SchemaAbiType {\n if (schemaIndex < schema.staticFields.length) {\n return schema.staticFields[schemaIndex];\n }\n return schema.dynamicFields[schemaIndex - schema.staticFields.length];\n}\n","import { Hex } from \"viem\";\nimport { ValueSchema } from \"./common\";\nimport { isDynamicAbiType, isStaticAbiType, staticAbiTypeToByteLength } from \"@latticexyz/schema-type\";\n\n// TODO: add tests once we have corresponding tests for FieldLayout.sol (bytes32 -> FieldLayout and vice versa)\nexport function valueSchemaToFieldLayoutHex(valueSchema: ValueSchema): Hex {\n const staticFields = Object.values(valueSchema).filter(isStaticAbiType);\n const dynamicFields = Object.values(valueSchema).filter(isDynamicAbiType);\n\n const staticFieldLengths = staticFields.map((fieldType) => staticAbiTypeToByteLength[fieldType]);\n const staticDataLength = staticFieldLengths.reduce((dataLength, fieldLength) => dataLength + fieldLength, 0);\n\n return `0x${[\n staticDataLength.toString(16).padStart(4, \"0\"),\n staticFields.length.toString(16).padStart(2, \"0\"),\n dynamicFields.length.toString(16).padStart(2, \"0\"),\n ...staticFieldLengths.map((fieldLength) => fieldLength.toString(16).padStart(2, \"0\")),\n ]\n .join(\"\")\n .padEnd(64, \"0\")}`;\n}\n","import { isDynamicAbiType, isStaticAbiType } from \"@latticexyz/schema-type\";\nimport { Hex } from \"viem\";\nimport { ValueSchema } from \"./common\";\nimport { schemaToHex } from \"./schemaToHex\";\n\nexport function valueSchemaToHex(valueSchema: ValueSchema): Hex {\n return schemaToHex({\n staticFields: Object.values(valueSchema).filter(isStaticAbiType),\n dynamicFields: Object.values(valueSchema).filter(isDynamicAbiType),\n });\n}\n"],"mappings":"AAAA,OAAuD,oBAAAA,MAAwB,0BAGxE,SAASC,GAAiBC,EAAmC,CAClE,IAAMC,EAAgC,CAAC,EACjCC,EAAkC,CAAC,EACzC,QAAWC,KAAWH,EAChBF,EAAiBK,CAAO,EAAGD,EAAc,KAAKC,CAAO,EACpDF,EAAa,KAAKE,CAAO,EAEhC,MAAO,CAAE,aAAAF,EAAc,cAAAC,CAAc,CACvC,CCXA,OAAc,eAAAE,EAAa,YAAAC,MAAgB,OAC3C,OAAS,oBAAAC,MAAwB,2BACjC,OAGE,+BAAAC,EACA,6BAAAC,OACK,0BCPP,OAAc,cAAAC,EAAY,eAAAC,EAAa,aAAAC,MAAiB,OACxD,OAAS,oBAAAC,MAAwB,2BACjC,OAGE,6BAAAC,EACA,+BAAAC,MACK,0BCNP,OAAS,YAAAC,MAAgB,4BACzB,OAAwB,6BAAAC,MAAiC,0BAElD,IAAMC,EAAN,cAAoCF,CAAS,CACzC,KAAO,uBAChB,YAAYG,EAAY,CACtB,MAAM,cAAcA,wBAA4BA,EAAM,OAAS,gCAAgC,CACjG,CACF,EAEaC,EAAN,cAA6CJ,CAAS,CAClD,KAAO,iCAChB,YAAYG,EAAY,CACtB,MAAM,cAAcA,oBAAwBA,EAAM,OAAS,4CAA4C,CACzG,CACF,EAEaE,EAAN,cAAoDL,CAAS,CACzD,KAAO,wCAChB,YAAYG,EAAY,CACtB,MAAM,cAAcA,oBAAwBA,EAAM,OAAS,oDAAoD,CACjH,CACF,EAEaG,EAAN,cAAkDN,CAAS,CACvD,KAAO,sCAChB,YAAYO,EAAwBJ,EAAY,CAC9C,MACE,cAAcA,oBAAwBA,EAAM,OAAS,6BACnDF,EAA0BM,CAAO,EAAI,SAC/BA,SACV,CACF,CACF,EAEaC,EAAN,cAAiDR,CAAS,CACtD,KAAO,qCAChB,YAAYO,EAAwBJ,EAAY,CAC9C,MACE,cAAcA,oBAAwBA,EAAM,OAAS,iCACnDF,EAA0BM,CAAO,EAAI,SAC/BA,WACV,CACF,CACF,EAEaE,EAAN,cAA8CT,CAAS,CACnD,KAAO,kCAChB,YAAYU,EAAiBC,EAAuBC,EAAsB,CACxE,MACE,WAAWF,0BAAmCC,4DAAwEC,6EAExH,CACF,CACF,EAEaC,EAAN,cAA+Cb,CAAS,CACpD,KAAO,mCAChB,YAAYc,EAAwBH,EAAuBC,EAAsB,CAC/E,MACE,kBAAkBE,0BAA0CH,iEAA6EC,KAC3I,CACF,CACF,EDtDO,SAASG,EAGdC,EAAmBC,EAA2B,CAC9C,GAAIA,EAAK,OAAS,GAAKA,EAAK,OAAS,IAAM,EACzC,MAAM,IAAIC,EAAsBD,CAAI,EAItC,IADkBA,EAAK,OAAS,GAAK,IACpBE,EAA0BH,CAAO,EAChD,MAAM,IAAII,EAAoCJ,EAASC,CAAI,EAG7D,OAAQD,EAAS,CACf,IAAK,QACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,OACL,IAAK,QACL,IAAK,QACL,IAAK,QACL,IAAK,QACL,IAAK,QACL,IAAK,QACL,IAAK,QACL,IAAK,QACL,IAAK,QACL,IAAK,QACL,IAAK,QACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SAAU,CACb,IAAMK,EAAQC,EAAYL,EAAM,CAAE,OAAQD,EAAQ,WAAW,KAAK,CAAE,CAAC,EAC/DO,EAAmB,OAAOC,EAA4BR,CAAO,EACnE,GAAIO,IAAqB,SACvB,OAAO,OAAOF,CAAK,EAErB,GAAIE,IAAqB,SACvB,OAAOF,EAET,MAAM,IAAI,MAAM,kCAAkCE,oBAAmCP,IAAU,CACjG,CAEA,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,SACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,UACH,OAAOC,EAGT,IAAK,OACH,OAAOQ,EAAUR,CAAI,EAGvB,IAAK,UACH,OAAOS,EAAWT,CAAI,CAE1B,CAEA,OAAOU,EAAiBX,EAAS,gCAAgCA,GAAS,CAC5E,CDlIO,SAASY,EAGdC,EAAmBC,EAA2B,CAC9C,GAAID,IAAY,QACd,OAAOC,EAET,GAAID,IAAY,SACd,OAAOE,EAAYD,CAAI,EAGzB,GAAIA,EAAK,OAAS,GAAKA,EAAK,OAAS,IAAM,EACzC,MAAM,IAAIE,EAAsBF,CAAI,EAGtC,IAAMG,GAAYH,EAAK,OAAS,GAAK,EAErC,OAAQD,EAAS,CACf,IAAK,UACL,IAAK,WACL,IAAK,WACL,IAAK,WACL,IAAK,WACL,IAAK,WACL,IAAK,WACL,IAAK,WACL,IAAK,WACL,IAAK,WACL,IAAK,WACL,IAAK,WACL,IAAK,YACL,IAAK,YACL,IAAK,YACL,IAAK,YACL,IAAK,YACL,IAAK,YACL,IAAK,YACL,IAAK,YACL,IAAK,YACL,IAAK,YACL,IAAK,YACL,IAAK,YACL,IAAK,YACL,IAAK,YACL,IAAK,YACL,IAAK,YACL,IAAK,YACL,IAAK,YACL,IAAK,YACL,IAAK,YACL,IAAK,SACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,UACL,IAAK,WACL,IAAK,WACL,IAAK,WACL,IAAK,WACL,IAAK,WACL,IAAK,WACL,IAAK,WACL,IAAK,WACL,IAAK,WACL,IAAK,WACL,IAAK,WACL,IAAK,WACL,IAAK,WACL,IAAK,WACL,IAAK,WACL,IAAK,WACL,IAAK,WACL,IAAK,WACL,IAAK,WACL,IAAK,WACL,IAAK,WACL,IAAK,WACL,IAAK,WACL,IAAK,WACL,IAAK,WACL,IAAK,WACL,IAAK,WACL,IAAK,WACL,IAAK,WACL,IAAK,YACL,IAAK,YACL,IAAK,YACL,IAAK,YACL,IAAK,YACL,IAAK,YACL,IAAK,YACL,IAAK,YACL,IAAK,YACL,IAAK,YACL,IAAK,YACL,IAAK,YACL,IAAK,YACL,IAAK,YACL,IAAK,YACL,IAAK,YACL,IAAK,YACL,IAAK,YACL,IAAK,YACL,IAAK,YACL,IAAK,YACL,IAAK,YACL,IAAK,YACL,IAAK,SACL,IAAK,YAAa,CAChB,IAAMK,EAAgBC,EAA4BN,CAAO,EACnDO,EAAiBC,GAA0BH,CAAa,EAC9D,GAAID,EAAWG,IAAmB,EAChC,MAAM,IAAIE,EAAmCJ,EAAeJ,CAAI,EAMlE,OAJc,IAAI,MAAMG,EAAWG,CAAc,EAAE,KAAK,MAAS,EAAE,IAAI,CAACG,EAAGC,IAAM,CAC/E,IAAMC,EAAWC,EAASZ,EAAMU,EAAIJ,GAAiBI,EAAI,GAAKJ,CAAc,EAC5E,OAAOO,EAAkBT,EAAeO,CAAQ,CAClD,CAAC,CAEH,CACF,CAEA,OAAOG,EAAiBf,EAAS,iCAAiCA,GAAS,CAC7E,CG/IA,OAAsD,oBAAAgB,OAAwB,0BAIvE,SAASC,GAGdC,EAAmBC,EAA2B,CAC9C,OACEC,GAAiBF,CAAO,EAAIG,EAAmBH,EAASC,CAAI,EAAIG,EAAkBJ,EAASC,CAAI,CAEnG,CCZA,OAAc,uBAAAI,OAA2B,OAOlC,SAASC,EAAeC,EAAmBC,EAAiD,CACjG,GAAID,EAAU,aAAa,SAAWC,EAAS,OAC7C,MAAM,IAAI,MACR,oBAAoBA,EAAS,2CAA2CD,EAAU,aAAa,QACjG,EAEF,OAAOC,EAAS,IACd,CAACC,EAAKC,IAAUL,GAAoB,CAAC,CAAE,KAAME,EAAU,aAAaG,CAAK,CAAE,CAAC,EAAGD,CAAG,EAAE,CAAC,CACvF,CACF,CCZO,SAASE,GACdC,EACAC,EAC6B,CAE7B,IAAMC,EAAYC,EAAe,CAAE,aAAc,OAAO,OAAOH,CAAS,EAAG,cAAe,CAAC,CAAE,EAAGC,CAAI,EAEpG,OAAO,OAAO,YACZ,OAAO,KAAKD,CAAS,EAAE,IAAI,CAACI,EAAMC,IAAM,CAACD,EAAMF,EAAUG,CAAC,CAAC,CAAC,CAC9D,CACF,CCdA,OAGE,6BAAAC,GACA,gCAAAC,OACK,0BCDP,OAAS,WAAAC,MAAe,qBASjB,SAASC,EAAmBC,EAGjC,CACA,GAAIA,EAAK,SAAW,GAClB,MAAM,IAAIC,EAAsCD,CAAI,EAGtD,IAAME,EAAkBC,EAAkB,SAAUL,EAAQE,EAAM,GAAK,EAAG,EAAE,CAAC,EAEvEI,EAA2BC,EAAmB,WAAYP,EAAQE,EAAM,EAAG,GAAK,CAAC,CAAC,EAElFM,EAAmB,OAAO,OAAO,CAAC,GAAGF,CAAwB,EAAE,QAAQ,CAAC,EAExEG,EAAe,OAAOD,EAAiB,OAAO,CAACE,EAAOC,IAAWD,EAAQC,EAAQ,CAAC,CAAC,EACzF,GAAIF,IAAiBL,EACnB,MAAM,IAAIQ,EAAiCV,EAAME,EAAiBK,CAAY,EAGhF,MAAO,CAAE,gBAAAL,EAAiB,iBAAAI,CAAiB,CAC7C,CCjCA,OAAwB,6BAAAK,OAAiC,0BAElD,SAASC,EAAiBC,EAAgD,CAC/E,OAAOA,EAAa,OAAO,CAACC,EAAQC,IAAcD,EAASH,GAA0BI,CAAS,EAAG,CAAC,CACpG,CFQA,OAAS,WAAAC,MAAe,qBAGjB,SAASC,EAAaC,EAAqBC,EAAoE,CACpH,IAAMC,EAAyD,CAAC,EAE5DC,EAAc,EAClBH,EAAY,aAAa,QAASI,GAAc,CAC9C,IAAMC,EAAkBC,GAA0BF,CAAS,EACrDG,EAAQC,EAAkBJ,EAAWN,EAAQG,EAAME,EAAaA,EAAcE,CAAe,CAAC,EACpGF,GAAeE,EACfH,EAAO,KAAKK,CAAK,CACnB,CAAC,EAGD,IAAME,EAAyBC,EAAiBV,EAAY,YAAY,EAClEW,EAAyBR,EAY/B,GAXIQ,IAA2BF,GAC7B,QAAQ,KACN,mJACA,CACE,eAAgBA,EAChB,aAAcE,EACd,YAAAR,CACF,CACF,EAGEH,EAAY,cAAc,OAAS,EAAG,CACxC,IAAMY,EAAaC,EAAmBf,EAAQG,EAAME,EAAaA,EAAc,EAAE,CAAC,EAClFA,GAAe,GAEfH,EAAY,cAAc,QAAQ,CAACI,EAAWU,IAAM,CAClD,IAAMC,EAAaH,EAAW,iBAAiBE,CAAC,EAChD,GAAIC,EAAa,EAAG,CAClB,IAAMR,EAAQS,EAAmBZ,EAAWN,EAAQG,EAAME,EAAaA,EAAcY,CAAU,CAAC,EAChGZ,GAAeY,EACfb,EAAO,KAAKK,CAAK,OAEjBL,EAAO,KAAKe,GAA6Bb,CAAS,CAAC,CAEvD,CAAC,EAGD,IAAMc,EAA0Bf,EAAc,GAAKQ,EAE/C,OAAOO,CAAuB,IAAMN,EAAW,iBACjD,QAAQ,KACN,qIACA,CACE,eAAgBA,EAAW,gBAC3B,aAAcM,EACd,YAAAf,CACF,CACF,EAIJ,OAAOD,CACT,CGvEA,OAAS,mBAAAiB,GAAiB,oBAAAC,OAAwB,0BAK3C,SAASC,EAAyCC,EAAsBC,EAAwC,CACrH,IAAMC,EAAe,OAAO,OAAOF,CAAW,EAAE,OAAOG,EAAe,EAChEC,EAAgB,OAAO,OAAOJ,CAAW,EAAE,OAAOK,EAAgB,EAGlEC,EAAaC,EAAa,CAAE,aAAAL,EAAc,cAAAE,CAAc,EAAGH,CAAI,EAErE,OAAO,OAAO,YACZ,OAAO,KAAKD,CAAW,EAAE,IAAI,CAACQ,EAAMC,IAAM,CAACD,EAAMF,EAAWG,CAAC,CAAC,CAAC,CACjE,CACF,CCfA,OAAS,aAAAC,OAAiB,OAC1B,OAAS,mBAAAC,OAAuB,0BAIhC,OAAS,WAAAC,OAAe,qBAEjB,SAASC,GACdC,EACA,CAAE,WAAAC,EAAY,eAAAC,EAAgB,YAAAC,CAAY,EACb,CAC7B,OAAOC,EACLJ,EACAK,GAAU,CACRP,GAAQG,EAAY,EAAGK,EAAiB,OAAO,OAAON,CAAW,EAAE,OAAOO,EAAe,CAAC,CAAC,EAC3FL,EACAC,CACF,CAAC,CACH,CACF,CCnBA,OAAwB,+BAAAK,GAA6B,kBAAAC,OAAsB,0BAE3E,OAAc,gBAAAC,MAAoB,OAE3B,SAASC,EACdC,EACAC,EACK,CACL,GAAIJ,GAAeG,CAAS,GAAK,MAAM,QAAQC,CAAK,EAAG,CACrD,IAAMC,EAAkBN,GAA4BI,CAAS,EAE7D,OAAOC,EAAM,SAAW,EACpB,KACAH,EACEG,EAAM,IAAI,IAAMC,CAAe,EAC/BD,CACF,EAEN,OAAOH,EAAa,CAACE,CAAS,EAAG,CAACC,CAAK,CAAC,CAC1C,CCnBA,OAAS,mBAAAE,OAAuB,0BCChC,OAAc,uBAAAC,OAA2B,OAIlC,SAASC,EAAeC,EAAmBC,EAAwC,CACxF,OAAOA,EAAS,IAAI,CAACC,EAAKC,IAAUL,GAAoB,CAAC,CAAE,KAAME,EAAU,aAAaG,CAAK,CAAE,CAAC,EAAG,CAACD,CAAG,CAAC,CAAC,CAC3G,CDFO,SAASE,GAAqCC,EAAoBC,EAAyC,CAChH,IAAMC,EAAe,OAAO,OAAOF,CAAS,EAAE,OAAOG,EAAe,EAEpE,OAAOC,EAAe,CAAE,aAAAF,EAAc,cAAe,CAAC,CAAE,EAAG,OAAO,OAAOD,CAAG,CAAC,CAC/E,CEHO,SAASI,GACdC,EACAC,EACK,CACL,IAAMC,EAAeD,EAAO,MAAM,EAAGD,EAAY,aAAa,MAAM,EAC9DG,EAAgBF,EAAO,MAAMD,EAAY,aAAa,MAAM,EAE5DI,EAAaF,EAChB,IAAI,CAACG,EAAOC,IAAMC,EAAYP,EAAY,aAAaM,CAAC,EAAGD,CAAK,EAAE,QAAQ,MAAO,EAAE,CAAC,EACpF,KAAK,EAAE,EAEV,GAAIL,EAAY,cAAc,SAAW,EAAG,MAAO,KAAKI,IAExD,IAAMI,EAAmBL,EAAc,IAAI,CAACE,EAAOC,IACjDC,EAAYP,EAAY,cAAcM,CAAC,EAAGD,CAAK,EAAE,QAAQ,MAAO,EAAE,CACpE,EAEMI,EAA0BD,EAAiB,IAAKH,GAAUA,EAAM,OAAS,CAAC,EAAE,QAAQ,EACpFK,EAAyBD,EAAwB,OAAO,CAACE,EAAOC,IAAWD,EAAQ,OAAOC,CAAM,EAAG,EAAE,EAErGC,EAAcL,EAAiB,KAAK,EAAE,EAEtCM,EAAgB,GAAGL,EACtB,IAAKG,GAAWL,EAAY,SAAUK,CAAM,EAAE,QAAQ,MAAO,EAAE,CAAC,EAChE,KAAK,EAAE,IAAIL,EAAY,SAAUG,CAAsB,EAAE,QAAQ,MAAO,EAAE,IAAI,SAAS,GAAI,GAAG,EAEjG,MAAO,KAAKN,IAAaU,IAAgBD,GAC3C,CCjCA,OAAc,aAAAE,OAAiB,OCA/B,OAGE,mBAAAC,GACA,oBAAAC,OAGK,0BACP,OAAS,aAAAC,MAAiB,OCR1B,OAAc,aAAAC,GAAW,UAAAC,GAAQ,QAAAC,OAAY,OAGtC,SAASC,EAAcC,EAAoB,CAChD,IAAMC,EAAcD,EAAO,IAAIE,EAAI,EAAE,QAAQ,EACvCC,EAAkBF,EAAY,OAAO,CAACG,EAAOC,IAAWD,EAAQ,OAAOC,CAAM,EAAG,EAAE,EAExF,OAAOC,GACLC,GAAU,CAAC,GAAGN,EAAY,IAAKI,GAAWG,EAAY,SAAUH,CAAM,CAAC,EAAGG,EAAY,SAAUL,CAAe,CAAC,CAAC,EACjH,CAAE,KAAM,GAAI,IAAK,MAAO,CAC1B,CACF,CDEO,SAASM,EACdC,EACAC,EACW,CACX,IAAMC,EAAqB,OAAO,QAAQF,CAAW,EAC/CG,EAAeD,EAAmB,OAAO,CAAC,CAAC,CAAEE,CAAI,IAAMC,GAAgBD,CAAI,CAAC,EAC5EE,EAAgBJ,EAAmB,OAAO,CAAC,CAAC,CAAEE,CAAI,IAAMG,GAAiBH,CAAI,CAAC,EAI9EI,EAAsBL,EAAa,IAAI,CAAC,CAACM,EAAML,CAAI,IAAMM,EAAYN,EAAMH,EAAMQ,CAAI,CAAwB,CAAC,EAC9GE,EAAuBL,EAAc,IAAI,CAAC,CAACG,EAAML,CAAI,IACzDM,EAAYN,EAAMH,EAAMQ,CAAI,CAAyB,CACvD,EAEMG,EAAiBC,EAAcF,CAAoB,EAEzD,MAAO,CACL,WAAYG,EAAUN,CAAmB,EACzC,eAAAI,EACA,YAAaE,EAAUH,CAAoB,CAC7C,CACF,CD/BO,SAASI,GACdC,EACAC,EACK,CACL,GAAM,CAAE,WAAAC,EAAY,eAAAC,EAAgB,YAAAC,CAAY,EAAIC,EAAgBL,EAAaC,CAAK,EACtF,OAAOK,GAAU,CAACJ,EAAYC,EAAgBC,CAAW,CAAC,CAC5D,CGNO,SAASG,GAAiBC,EAA+B,CAE9D,MAAO,KAAK,CADaA,EAAY,mBAAmB,OAAO,CAACC,EAAaC,IAAWD,EAAcC,EAAQ,CAAC,EAE5F,SAAS,EAAE,EAAE,SAAS,EAAG,GAAG,EAC7CF,EAAY,mBAAmB,OAAO,SAAS,EAAE,EAAE,SAAS,EAAG,GAAG,EAClEA,EAAY,iBAAiB,SAAS,EAAE,EAAE,SAAS,EAAG,GAAG,EACzD,GAAGA,EAAY,mBAAmB,IAAKG,GAAeA,EAAW,SAAS,EAAE,EAAE,SAAS,EAAG,GAAG,CAAC,CAChG,EACG,KAAK,EAAE,EACP,OAAO,GAAI,GAAG,GACnB,CCdA,OAAwC,kBAAAC,EAAgB,6BAAAC,OAAiC,0BACzF,OAAc,eAAAC,EAAa,YAAAC,MAAgB,OAIpC,SAASC,EAAYC,EAAmB,CAC7C,GAAIA,EAAK,SAAW,GAClB,MAAM,IAAIC,EAA+BD,CAAI,EAG/C,IAAME,EAAmBC,EAAYC,EAASJ,EAAM,EAAG,CAAC,CAAC,EACnDK,EAAkBF,EAAYC,EAASJ,EAAM,EAAG,CAAC,CAAC,EAClDM,EAAmBH,EAAYC,EAASJ,EAAM,EAAG,CAAC,CAAC,EACnDO,EAAgC,CAAC,EACjCC,EAAkC,CAAC,EAEzC,QAASC,EAAI,EAAGA,EAAI,EAAIJ,EAAiBI,IAAK,CAC5C,IAAMC,EAAkBP,EAAYC,EAASJ,EAAMS,EAAGA,EAAI,CAAC,CAAC,EAC5DF,EAAa,KAAKI,EAAeD,CAAe,CAAkB,EAEpE,QAASD,EAAI,EAAIJ,EAAiBI,EAAI,EAAIJ,EAAkBC,EAAkBG,IAAK,CACjF,IAAMC,EAAkBP,EAAYC,EAASJ,EAAMS,EAAGA,EAAI,CAAC,CAAC,EAC5DD,EAAc,KAAKG,EAAeD,CAAe,CAAmB,EAItE,IAAME,EAAyBL,EAAa,OAAO,CAACM,EAAKC,IAAcD,EAAME,GAA0BD,CAAS,EAAG,CAAC,EACpH,GAAIF,IAA2BV,EAC7B,cAAQ,KACN,WAAWF,0BAA6BE,4DAA2EU,6EAErH,EACM,IAAII,EAAgChB,EAAME,EAAkBU,CAAsB,EAG1F,MAAO,CAAE,aAAAL,EAAc,cAAAC,CAAc,CACvC,CCpCA,OAAc,YAAAS,MAAgB,OAIvB,SAASC,GAAiBC,EAAwB,CACvD,IAAMC,EAAcC,EAAYC,EAASH,EAAM,EAAG,EAAE,CAAC,EAErD,MAAO,CACL,UAFgBE,EAAYC,EAASH,EAAM,GAAI,EAAE,CAAC,EAGlD,YAAAC,CACF,CACF,CCXA,OAAS,mBAAAG,OAAuB,0BCAhC,OAAS,kBAAAC,MAAsB,0BAMxB,SAASC,EAAYC,EAAqB,CAC/C,IAAMC,EAAoBD,EAAO,aAAa,IAAKE,GAAYC,EAAe,QAAQD,CAAO,CAAC,EACxFE,EAAqBJ,EAAO,cAAc,IAAKE,GAAYC,EAAe,QAAQD,CAAO,CAAC,EAChG,MAAO,KAAK,CACVG,EAAiBL,EAAO,YAAY,EAAE,SAAS,EAAE,EAAE,SAAS,EAAG,GAAG,EAClEA,EAAO,aAAa,OAAO,SAAS,EAAE,EAAE,SAAS,EAAG,GAAG,EACvDA,EAAO,cAAc,OAAO,SAAS,EAAE,EAAE,SAAS,EAAG,GAAG,EACxD,GAAGC,EAAkB,IAAKK,GAAeA,EAAW,SAAS,EAAE,EAAE,SAAS,EAAG,GAAG,CAAC,EACjF,GAAGF,EAAmB,IAAKE,GAAeA,EAAW,SAAS,EAAE,EAAE,SAAS,EAAG,GAAG,CAAC,CACpF,EACG,KAAK,EAAE,EACP,OAAO,GAAI,GAAG,GACnB,CDbO,SAASC,GAAeC,EAA2B,CACxD,OAAOC,EAAY,CAAE,aAAc,OAAO,OAAOD,CAAS,EAAE,OAAOE,EAAe,EAAG,cAAe,CAAC,CAAE,CAAC,CAC1G,CEJO,SAASC,GAAqBC,EAAgBC,EAAoC,CACvF,OAAIA,EAAcD,EAAO,aAAa,OAC7BA,EAAO,aAAaC,CAAW,EAEjCD,EAAO,cAAcC,EAAcD,EAAO,aAAa,MAAM,CACtE,CCNA,OAAS,oBAAAE,GAAkB,mBAAAC,GAAiB,6BAAAC,OAAiC,0BAGtE,SAASC,GAA4BC,EAA+B,CACzE,IAAMC,EAAe,OAAO,OAAOD,CAAW,EAAE,OAAOH,EAAe,EAChEK,EAAgB,OAAO,OAAOF,CAAW,EAAE,OAAOJ,EAAgB,EAElEO,EAAqBF,EAAa,IAAKG,GAAcN,GAA0BM,CAAS,CAAC,EAG/F,MAAO,KAAK,CAFaD,EAAmB,OAAO,CAACE,EAAYC,IAAgBD,EAAaC,EAAa,CAAC,EAGxF,SAAS,EAAE,EAAE,SAAS,EAAG,GAAG,EAC7CL,EAAa,OAAO,SAAS,EAAE,EAAE,SAAS,EAAG,GAAG,EAChDC,EAAc,OAAO,SAAS,EAAE,EAAE,SAAS,EAAG,GAAG,EACjD,GAAGC,EAAmB,IAAKG,GAAgBA,EAAY,SAAS,EAAE,EAAE,SAAS,EAAG,GAAG,CAAC,CACtF,EACG,KAAK,EAAE,EACP,OAAO,GAAI,GAAG,GACnB,CCpBA,OAAS,oBAAAC,GAAkB,mBAAAC,OAAuB,0BAK3C,SAASC,GAAiBC,EAA+B,CAC9D,OAAOC,EAAY,CACjB,aAAc,OAAO,OAAOD,CAAW,EAAE,OAAOE,EAAe,EAC/D,cAAe,OAAO,OAAOF,CAAW,EAAE,OAAOG,EAAgB,CACnE,CAAC,CACH","names":["isDynamicAbiType","abiTypesToSchema","abiTypes","staticFields","dynamicFields","abiType","hexToString","sliceHex","assertExhaustive","arrayAbiTypeToStaticAbiType","staticAbiTypeToByteLength","getAddress","hexToBigInt","hexToBool","assertExhaustive","staticAbiTypeToByteLength","staticAbiTypeToDefaultValue","MUDError","staticAbiTypeToByteLength","InvalidHexLengthError","value","InvalidHexLengthForSchemaError","InvalidHexLengthForPackedCounterError","InvalidHexLengthForStaticFieldError","abiType","InvalidHexLengthForArrayFieldError","SchemaStaticLengthMismatchError","schemaData","definedLength","summedLength","PackedCounterLengthMismatchError","packedCounterData","decodeStaticField","abiType","data","InvalidHexLengthError","staticAbiTypeToByteLength","InvalidHexLengthForStaticFieldError","value","hexToBigInt","defaultValueType","staticAbiTypeToDefaultValue","hexToBool","getAddress","assertExhaustive","decodeDynamicField","abiType","data","hexToString","InvalidHexLengthError","dataSize","staticAbiType","arrayAbiTypeToStaticAbiType","itemByteLength","staticAbiTypeToByteLength","InvalidHexLengthForArrayFieldError","_","i","itemData","sliceHex","decodeStaticField","assertExhaustive","isDynamicAbiType","decodeField","abiType","data","isDynamicAbiType","decodeDynamicField","decodeStaticField","decodeAbiParameters","decodeKeyTuple","keySchema","keyTuple","key","index","decodeKey","keySchema","data","keyValues","decodeKeyTuple","name","i","staticAbiTypeToByteLength","dynamicAbiTypeToDefaultValue","readHex","hexToPackedCounter","data","InvalidHexLengthForPackedCounterError","totalByteLength","decodeStaticField","reversedFieldByteLengths","decodeDynamicField","fieldByteLengths","summedLength","total","length","PackedCounterLengthMismatchError","staticAbiTypeToByteLength","staticDataLength","staticFields","length","fieldType","readHex","decodeRecord","valueSchema","data","values","bytesOffset","fieldType","fieldByteLength","staticAbiTypeToByteLength","value","decodeStaticField","schemaStaticDataLength","staticDataLength","actualStaticDataLength","dataLayout","hexToPackedCounter","i","dataLength","decodeDynamicField","dynamicAbiTypeToDefaultValue","actualDynamicDataLength","isStaticAbiType","isDynamicAbiType","decodeValue","valueSchema","data","staticFields","isStaticAbiType","dynamicFields","isDynamicAbiType","valueTuple","decodeRecord","name","i","concatHex","isStaticAbiType","readHex","decodeValueArgs","valueSchema","staticData","encodedLengths","dynamicData","decodeValue","concatHex","staticDataLength","isStaticAbiType","arrayAbiTypeToStaticAbiType","isArrayAbiType","encodePacked","encodeField","fieldType","value","staticFieldType","isStaticAbiType","encodeAbiParameters","encodeKeyTuple","keySchema","keyTuple","key","index","encodeKey","keySchema","key","staticFields","isStaticAbiType","encodeKeyTuple","encodeRecord","valueSchema","values","staticValues","dynamicValues","staticData","value","i","encodeField","dynamicDataItems","dynamicFieldByteLengths","dynamicTotalByteLength","total","length","dynamicData","packedCounter","concatHex","isStaticAbiType","isDynamicAbiType","concatHex","concatHex","padHex","size","encodeLengths","values","byteLengths","size","totalByteLength","total","length","padHex","concatHex","encodeField","encodeValueArgs","valueSchema","value","valueSchemaEntries","staticFields","type","isStaticAbiType","dynamicFields","isDynamicAbiType","encodedStaticValues","name","encodeField","encodedDynamicValues","encodedLengths","encodeLengths","concatHex","encodeValue","valueSchema","value","staticData","encodedLengths","dynamicData","encodeValueArgs","concatHex","fieldLayoutToHex","fieldLayout","totalLength","length","schemaType","schemaAbiTypes","staticAbiTypeToByteLength","hexToNumber","sliceHex","hexToSchema","data","InvalidHexLengthForSchemaError","staticDataLength","hexToNumber","sliceHex","numStaticFields","numDynamicFields","staticFields","dynamicFields","i","schemaTypeIndex","schemaAbiTypes","actualStaticDataLength","acc","fieldType","staticAbiTypeToByteLength","SchemaStaticLengthMismatchError","sliceHex","hexToTableSchema","data","valueSchema","hexToSchema","sliceHex","isStaticAbiType","schemaAbiTypes","schemaToHex","schema","staticSchemaTypes","abiType","schemaAbiTypes","dynamicSchemaTypes","staticDataLength","schemaType","keySchemaToHex","keySchema","schemaToHex","isStaticAbiType","schemaIndexToAbiType","schema","schemaIndex","isDynamicAbiType","isStaticAbiType","staticAbiTypeToByteLength","valueSchemaToFieldLayoutHex","valueSchema","staticFields","dynamicFields","staticFieldLengths","fieldType","dataLength","fieldLength","isDynamicAbiType","isStaticAbiType","valueSchemaToHex","valueSchema","schemaToHex","isStaticAbiType","isDynamicAbiType"]}
1
+ {"version":3,"sources":["../src/abiTypesToSchema.ts","../src/decodeDynamicField.ts","../src/decodeStaticField.ts","../src/errors.ts","../src/decodeField.ts","../src/decodeKeyTuple.ts","../src/decodeKey.ts","../src/decodeRecord.ts","../src/hexToPackedCounter.ts","../src/staticDataLength.ts","../src/decodeValue.ts","../src/decodeValueArgs.ts","../src/encodeField.ts","../src/encodeKey.ts","../src/encodeKeyTuple.ts","../src/encodeRecord.ts","../src/encodeValue.ts","../src/encodeValueArgs.ts","../src/encodeLengths.ts","../src/fieldLayoutToHex.ts","../src/hexToSchema.ts","../src/hexToTableSchema.ts","../src/keySchemaToHex.ts","../src/schemaToHex.ts","../src/schemaIndexToAbiType.ts","../src/valueSchemaToFieldLayoutHex.ts","../src/valueSchemaToHex.ts"],"sourcesContent":["import { DynamicAbiType, SchemaAbiType, StaticAbiType, isDynamicAbiType } from \"@latticexyz/schema-type\";\nimport { Schema } from \"./common\";\n\nexport function abiTypesToSchema(abiTypes: SchemaAbiType[]): Schema {\n const staticFields: StaticAbiType[] = [];\n const dynamicFields: DynamicAbiType[] = [];\n for (const abiType of abiTypes) {\n if (isDynamicAbiType(abiType)) dynamicFields.push(abiType);\n else staticFields.push(abiType);\n }\n return { staticFields, dynamicFields };\n}\n","import { Hex, hexToString, sliceHex } from \"viem\";\nimport { assertExhaustive } from \"@latticexyz/common/utils\";\nimport {\n DynamicAbiType,\n DynamicAbiTypeToPrimitiveType,\n arrayAbiTypeToStaticAbiType,\n staticAbiTypeToByteLength,\n} from \"@latticexyz/schema-type\";\nimport { decodeStaticField } from \"./decodeStaticField\";\nimport { InvalidHexLengthError, InvalidHexLengthForArrayFieldError } from \"./errors\";\n\n// TODO: require size/length for dynamic fields, because hex might be longer (sometimes we just move the length pointer of arrays without updating the value)\n// this means the error should probably change from \"invalid length\" to \"too short\", which viem has that we could reuse?\n\nexport function decodeDynamicField<\n TAbiType extends DynamicAbiType,\n TPrimitiveType extends DynamicAbiTypeToPrimitiveType<TAbiType>,\n>(abiType: TAbiType, data: Hex): TPrimitiveType {\n if (abiType === \"bytes\") {\n return data as TPrimitiveType;\n }\n if (abiType === \"string\") {\n return hexToString(data) as TPrimitiveType;\n }\n\n if (data.length > 3 && data.length % 2 !== 0) {\n throw new InvalidHexLengthError(data);\n }\n\n const dataSize = (data.length - 2) / 2;\n\n switch (abiType) {\n case \"uint8[]\":\n case \"uint16[]\":\n case \"uint24[]\":\n case \"uint32[]\":\n case \"uint40[]\":\n case \"uint48[]\":\n case \"uint56[]\":\n case \"uint64[]\":\n case \"uint72[]\":\n case \"uint80[]\":\n case \"uint88[]\":\n case \"uint96[]\":\n case \"uint104[]\":\n case \"uint112[]\":\n case \"uint120[]\":\n case \"uint128[]\":\n case \"uint136[]\":\n case \"uint144[]\":\n case \"uint152[]\":\n case \"uint160[]\":\n case \"uint168[]\":\n case \"uint176[]\":\n case \"uint184[]\":\n case \"uint192[]\":\n case \"uint200[]\":\n case \"uint208[]\":\n case \"uint216[]\":\n case \"uint224[]\":\n case \"uint232[]\":\n case \"uint240[]\":\n case \"uint248[]\":\n case \"uint256[]\":\n case \"int8[]\":\n case \"int16[]\":\n case \"int24[]\":\n case \"int32[]\":\n case \"int40[]\":\n case \"int48[]\":\n case \"int56[]\":\n case \"int64[]\":\n case \"int72[]\":\n case \"int80[]\":\n case \"int88[]\":\n case \"int96[]\":\n case \"int104[]\":\n case \"int112[]\":\n case \"int120[]\":\n case \"int128[]\":\n case \"int136[]\":\n case \"int144[]\":\n case \"int152[]\":\n case \"int160[]\":\n case \"int168[]\":\n case \"int176[]\":\n case \"int184[]\":\n case \"int192[]\":\n case \"int200[]\":\n case \"int208[]\":\n case \"int216[]\":\n case \"int224[]\":\n case \"int232[]\":\n case \"int240[]\":\n case \"int248[]\":\n case \"int256[]\":\n case \"bytes1[]\":\n case \"bytes2[]\":\n case \"bytes3[]\":\n case \"bytes4[]\":\n case \"bytes5[]\":\n case \"bytes6[]\":\n case \"bytes7[]\":\n case \"bytes8[]\":\n case \"bytes9[]\":\n case \"bytes10[]\":\n case \"bytes11[]\":\n case \"bytes12[]\":\n case \"bytes13[]\":\n case \"bytes14[]\":\n case \"bytes15[]\":\n case \"bytes16[]\":\n case \"bytes17[]\":\n case \"bytes18[]\":\n case \"bytes19[]\":\n case \"bytes20[]\":\n case \"bytes21[]\":\n case \"bytes22[]\":\n case \"bytes23[]\":\n case \"bytes24[]\":\n case \"bytes25[]\":\n case \"bytes26[]\":\n case \"bytes27[]\":\n case \"bytes28[]\":\n case \"bytes29[]\":\n case \"bytes30[]\":\n case \"bytes31[]\":\n case \"bytes32[]\":\n case \"bool[]\":\n case \"address[]\": {\n const staticAbiType = arrayAbiTypeToStaticAbiType(abiType);\n const itemByteLength = staticAbiTypeToByteLength[staticAbiType];\n if (dataSize % itemByteLength !== 0) {\n throw new InvalidHexLengthForArrayFieldError(staticAbiType, data);\n }\n const items = new Array(dataSize / itemByteLength).fill(undefined).map((_, i) => {\n const itemData = sliceHex(data, i * itemByteLength, (i + 1) * itemByteLength);\n return decodeStaticField(staticAbiType, itemData);\n });\n return items as TPrimitiveType;\n }\n }\n\n return assertExhaustive(abiType, `Unsupported dynamic ABI type: ${abiType}`);\n}\n","import { Hex, getAddress, hexToBigInt, hexToBool } from \"viem\";\nimport { assertExhaustive } from \"@latticexyz/common/utils\";\nimport {\n StaticAbiType,\n StaticAbiTypeToPrimitiveType,\n staticAbiTypeToByteLength,\n staticAbiTypeToDefaultValue,\n} from \"@latticexyz/schema-type\";\nimport { InvalidHexLengthError, InvalidHexLengthForStaticFieldError } from \"./errors\";\n\nexport function decodeStaticField<\n TAbiType extends StaticAbiType,\n TPrimitiveType extends StaticAbiTypeToPrimitiveType<TAbiType>,\n>(abiType: TAbiType, data: Hex): TPrimitiveType {\n if (data.length > 3 && data.length % 2 !== 0) {\n throw new InvalidHexLengthError(data);\n }\n\n const dataSize = (data.length - 2) / 2;\n if (dataSize !== staticAbiTypeToByteLength[abiType]) {\n throw new InvalidHexLengthForStaticFieldError(abiType, data);\n }\n\n switch (abiType) {\n case \"uint8\":\n case \"uint16\":\n case \"uint24\":\n case \"uint32\":\n case \"uint40\":\n case \"uint48\":\n case \"uint56\":\n case \"uint64\":\n case \"uint72\":\n case \"uint80\":\n case \"uint88\":\n case \"uint96\":\n case \"uint104\":\n case \"uint112\":\n case \"uint120\":\n case \"uint128\":\n case \"uint136\":\n case \"uint144\":\n case \"uint152\":\n case \"uint160\":\n case \"uint168\":\n case \"uint176\":\n case \"uint184\":\n case \"uint192\":\n case \"uint200\":\n case \"uint208\":\n case \"uint216\":\n case \"uint224\":\n case \"uint232\":\n case \"uint240\":\n case \"uint248\":\n case \"uint256\":\n case \"int8\":\n case \"int16\":\n case \"int24\":\n case \"int32\":\n case \"int40\":\n case \"int48\":\n case \"int56\":\n case \"int64\":\n case \"int72\":\n case \"int80\":\n case \"int88\":\n case \"int96\":\n case \"int104\":\n case \"int112\":\n case \"int120\":\n case \"int128\":\n case \"int136\":\n case \"int144\":\n case \"int152\":\n case \"int160\":\n case \"int168\":\n case \"int176\":\n case \"int184\":\n case \"int192\":\n case \"int200\":\n case \"int208\":\n case \"int216\":\n case \"int224\":\n case \"int232\":\n case \"int240\":\n case \"int248\":\n case \"int256\": {\n const value = hexToBigInt(data, { signed: abiType.startsWith(\"int\") });\n const defaultValueType = typeof staticAbiTypeToDefaultValue[abiType];\n if (defaultValueType === \"number\") {\n return Number(value) as TPrimitiveType;\n }\n if (defaultValueType === \"bigint\") {\n return value as TPrimitiveType;\n }\n throw new Error(`Unexpected default value type (${defaultValueType}) for ABI type (${abiType})`);\n }\n\n case \"bytes1\":\n case \"bytes2\":\n case \"bytes3\":\n case \"bytes4\":\n case \"bytes5\":\n case \"bytes6\":\n case \"bytes7\":\n case \"bytes8\":\n case \"bytes9\":\n case \"bytes10\":\n case \"bytes11\":\n case \"bytes12\":\n case \"bytes13\":\n case \"bytes14\":\n case \"bytes15\":\n case \"bytes16\":\n case \"bytes17\":\n case \"bytes18\":\n case \"bytes19\":\n case \"bytes20\":\n case \"bytes21\":\n case \"bytes22\":\n case \"bytes23\":\n case \"bytes24\":\n case \"bytes25\":\n case \"bytes26\":\n case \"bytes27\":\n case \"bytes28\":\n case \"bytes29\":\n case \"bytes30\":\n case \"bytes31\":\n case \"bytes32\": {\n return data as TPrimitiveType;\n }\n\n case \"bool\": {\n return hexToBool(data) as TPrimitiveType;\n }\n\n case \"address\": {\n return getAddress(data) as TPrimitiveType;\n }\n }\n\n return assertExhaustive(abiType, `Unsupported static ABI type: ${abiType}`);\n}\n","import { Hex } from \"viem\";\nimport { MUDError } from \"@latticexyz/common/errors\";\nimport { StaticAbiType, staticAbiTypeToByteLength } from \"@latticexyz/schema-type\";\n\nexport class InvalidHexLengthError extends MUDError {\n override name = \"InvalidHexValueError\";\n constructor(value: Hex) {\n super(`Hex value \"${value}\" is an odd length (${value.length - 2}). It must be an even length.`);\n }\n}\n\nexport class InvalidHexLengthForSchemaError extends MUDError {\n override name = \"InvalidHexLengthForSchemaError\";\n constructor(value: Hex) {\n super(`Hex value \"${value}\" has length of ${value.length - 2}, but expected length of 64 for a schema.`);\n }\n}\n\nexport class InvalidHexLengthForPackedCounterError extends MUDError {\n override name = \"InvalidHexLengthForPackedCounterError\";\n constructor(value: Hex) {\n super(`Hex value \"${value}\" has length of ${value.length - 2}, but expected length of 64 for a packed counter.`);\n }\n}\n\nexport class InvalidHexLengthForStaticFieldError extends MUDError {\n override name = \"InvalidHexLengthForStaticFieldError\";\n constructor(abiType: StaticAbiType, value: Hex) {\n super(\n `Hex value \"${value}\" has length of ${value.length - 2}, but expected length of ${\n staticAbiTypeToByteLength[abiType] * 2\n } for ${abiType} type.`,\n );\n }\n}\n\nexport class InvalidHexLengthForArrayFieldError extends MUDError {\n override name = \"InvalidHexLengthForArrayFieldError\";\n constructor(abiType: StaticAbiType, value: Hex) {\n super(\n `Hex value \"${value}\" has length of ${value.length - 2}, but expected a multiple of ${\n staticAbiTypeToByteLength[abiType] * 2\n } for ${abiType}[] type.`,\n );\n }\n}\n\nexport class SchemaStaticLengthMismatchError extends MUDError {\n override name = \"SchemaStaticLengthMismatchError\";\n constructor(schemaData: Hex, definedLength: number, summedLength: number) {\n super(\n `Schema \"${schemaData}\" static data length (${definedLength}) did not match the summed length of all static fields (${summedLength}). ` +\n `Is \\`staticAbiTypeToByteLength\\` up to date with Solidity schema types?`,\n );\n }\n}\n\nexport class PackedCounterLengthMismatchError extends MUDError {\n override name = \"PackedCounterLengthMismatchError\";\n constructor(packedCounterData: Hex, definedLength: bigint, summedLength: bigint) {\n super(\n `PackedCounter \"${packedCounterData}\" total bytes length (${definedLength}) did not match the summed length of all field byte lengths (${summedLength}).`,\n );\n }\n}\n","import { Hex } from \"viem\";\nimport { SchemaAbiType, SchemaAbiTypeToPrimitiveType, isDynamicAbiType } from \"@latticexyz/schema-type\";\nimport { decodeDynamicField } from \"./decodeDynamicField\";\nimport { decodeStaticField } from \"./decodeStaticField\";\n\nexport function decodeField<\n TAbiType extends SchemaAbiType,\n TPrimitiveType extends SchemaAbiTypeToPrimitiveType<TAbiType>,\n>(abiType: TAbiType, data: Hex): TPrimitiveType {\n return (\n isDynamicAbiType(abiType) ? decodeDynamicField(abiType, data) : decodeStaticField(abiType, data)\n ) as TPrimitiveType;\n}\n","import { Hex, decodeAbiParameters } from \"viem\";\nimport { StaticPrimitiveType } from \"@latticexyz/schema-type\";\nimport { Schema } from \"./common\";\n\n// key tuples are encoded in the same way as abi.encode, so we can decode them with viem\n\n/** @deprecated use `decodeKey` instead */\nexport function decodeKeyTuple(keySchema: Schema, keyTuple: readonly Hex[]): StaticPrimitiveType[] {\n if (keySchema.staticFields.length !== keyTuple.length) {\n throw new Error(\n `key tuple length ${keyTuple.length} does not match key schema length ${keySchema.staticFields.length}`,\n );\n }\n return keyTuple.map(\n (key, index) => decodeAbiParameters([{ type: keySchema.staticFields[index] }], key)[0] as StaticPrimitiveType,\n );\n}\n","import { Hex } from \"viem\";\nimport { SchemaToPrimitives, KeySchema } from \"./common\";\nimport { decodeKeyTuple } from \"./decodeKeyTuple\";\n\nexport function decodeKey<TSchema extends KeySchema>(\n keySchema: TSchema,\n data: readonly Hex[],\n): SchemaToPrimitives<TSchema> {\n // TODO: refactor and move all decodeKeyTuple logic into this method so we can delete decodeKeyTuple\n const keyValues = decodeKeyTuple({ staticFields: Object.values(keySchema), dynamicFields: [] }, data);\n\n return Object.fromEntries(\n Object.keys(keySchema).map((name, i) => [name, keyValues[i]]),\n ) as SchemaToPrimitives<TSchema>;\n}\n","import {\n StaticPrimitiveType,\n DynamicPrimitiveType,\n staticAbiTypeToByteLength,\n dynamicAbiTypeToDefaultValue,\n} from \"@latticexyz/schema-type\";\nimport { Hex } from \"viem\";\nimport { Schema } from \"./common\";\nimport { decodeDynamicField } from \"./decodeDynamicField\";\nimport { decodeStaticField } from \"./decodeStaticField\";\nimport { hexToPackedCounter } from \"./hexToPackedCounter\";\nimport { staticDataLength } from \"./staticDataLength\";\nimport { readHex } from \"@latticexyz/common\";\n\n/** @deprecated use `decodeValue` instead */\nexport function decodeRecord(valueSchema: Schema, data: Hex): readonly (StaticPrimitiveType | DynamicPrimitiveType)[] {\n const values: (StaticPrimitiveType | DynamicPrimitiveType)[] = [];\n\n let bytesOffset = 0;\n valueSchema.staticFields.forEach((fieldType) => {\n const fieldByteLength = staticAbiTypeToByteLength[fieldType];\n const value = decodeStaticField(fieldType, readHex(data, bytesOffset, bytesOffset + fieldByteLength));\n bytesOffset += fieldByteLength;\n values.push(value);\n });\n\n // Warn user if static data length doesn't match the value schema, because data corruption might be possible.\n const schemaStaticDataLength = staticDataLength(valueSchema.staticFields);\n const actualStaticDataLength = bytesOffset;\n if (actualStaticDataLength !== schemaStaticDataLength) {\n console.warn(\n \"Decoded static data length does not match value schema's expected static data length. Data may get corrupted. Is `getStaticByteLength` outdated?\",\n {\n expectedLength: schemaStaticDataLength,\n actualLength: actualStaticDataLength,\n bytesOffset,\n },\n );\n }\n\n if (valueSchema.dynamicFields.length > 0) {\n const dataLayout = hexToPackedCounter(readHex(data, bytesOffset, bytesOffset + 32));\n bytesOffset += 32;\n\n valueSchema.dynamicFields.forEach((fieldType, i) => {\n const dataLength = dataLayout.fieldByteLengths[i];\n if (dataLength > 0) {\n const value = decodeDynamicField(fieldType, readHex(data, bytesOffset, bytesOffset + dataLength));\n bytesOffset += dataLength;\n values.push(value);\n } else {\n values.push(dynamicAbiTypeToDefaultValue[fieldType]);\n }\n });\n\n // Warn user if dynamic data length doesn't match the dynamic data length, because data corruption might be possible.\n const actualDynamicDataLength = bytesOffset - 32 - actualStaticDataLength;\n // TODO: refactor this so we don't break for bytes offsets >UINT40\n if (BigInt(actualDynamicDataLength) !== dataLayout.totalByteLength) {\n console.warn(\n \"Decoded dynamic data length does not match data layout's expected data length. Data may get corrupted. Did the data layout change?\",\n {\n expectedLength: dataLayout.totalByteLength,\n actualLength: actualDynamicDataLength,\n bytesOffset,\n },\n );\n }\n }\n\n return values;\n}\n","import { Hex } from \"viem\";\nimport { decodeStaticField } from \"./decodeStaticField\";\nimport { decodeDynamicField } from \"./decodeDynamicField\";\nimport { InvalidHexLengthForPackedCounterError, PackedCounterLengthMismatchError } from \"./errors\";\nimport { readHex } from \"@latticexyz/common\";\n\n// Keep this logic in sync with PackedCounter.sol\n\n// - Last 7 bytes (uint56) are used for the total byte length of the dynamic data\n// - The next 5 byte (uint40) sections are used for the byte length of each field, indexed from right to left\n\n// We use byte lengths rather than item counts so that, on chain, we can slice without having to get the value schema first (and thus the field lengths of each dynamic type)\n\nexport function hexToPackedCounter(data: Hex): {\n totalByteLength: bigint;\n fieldByteLengths: readonly number[];\n} {\n if (data.length !== 66) {\n throw new InvalidHexLengthForPackedCounterError(data);\n }\n\n const totalByteLength = decodeStaticField(\"uint56\", readHex(data, 32 - 7, 32));\n // TODO: use value schema to make sure we only parse as many as we need (rather than zeroes at the end)?\n const reversedFieldByteLengths = decodeDynamicField(\"uint40[]\", readHex(data, 0, 32 - 7));\n // Reverse the lengths\n const fieldByteLengths = Object.freeze([...reversedFieldByteLengths].reverse());\n\n const summedLength = BigInt(fieldByteLengths.reduce((total, length) => total + length, 0));\n if (summedLength !== totalByteLength) {\n throw new PackedCounterLengthMismatchError(data, totalByteLength, summedLength);\n }\n\n return { totalByteLength, fieldByteLengths };\n}\n","import { StaticAbiType, staticAbiTypeToByteLength } from \"@latticexyz/schema-type\";\n\nexport function staticDataLength(staticFields: readonly StaticAbiType[]): number {\n return staticFields.reduce((length, fieldType) => length + staticAbiTypeToByteLength[fieldType], 0);\n}\n","import { isStaticAbiType, isDynamicAbiType } from \"@latticexyz/schema-type\";\nimport { Hex } from \"viem\";\nimport { SchemaToPrimitives, ValueSchema } from \"./common\";\nimport { decodeRecord } from \"./decodeRecord\";\n\nexport function decodeValue<TSchema extends ValueSchema>(valueSchema: TSchema, data: Hex): SchemaToPrimitives<TSchema> {\n const staticFields = Object.values(valueSchema).filter(isStaticAbiType);\n const dynamicFields = Object.values(valueSchema).filter(isDynamicAbiType);\n\n // TODO: refactor and move all decodeRecord logic into this method so we can delete decodeRecord\n const valueTuple = decodeRecord({ staticFields, dynamicFields }, data);\n\n return Object.fromEntries(\n Object.keys(valueSchema).map((name, i) => [name, valueTuple[i]]),\n ) as SchemaToPrimitives<TSchema>;\n}\n","import { concatHex } from \"viem\";\nimport { isStaticAbiType } from \"@latticexyz/schema-type\";\nimport { SchemaToPrimitives, ValueArgs, ValueSchema } from \"./common\";\nimport { decodeValue } from \"./decodeValue\";\nimport { staticDataLength } from \"./staticDataLength\";\nimport { readHex } from \"@latticexyz/common\";\n\nexport function decodeValueArgs<TSchema extends ValueSchema>(\n valueSchema: TSchema,\n { staticData, encodedLengths, dynamicData }: ValueArgs,\n): SchemaToPrimitives<TSchema> {\n return decodeValue(\n valueSchema,\n concatHex([\n readHex(staticData, 0, staticDataLength(Object.values(valueSchema).filter(isStaticAbiType))),\n encodedLengths,\n dynamicData,\n ]),\n );\n}\n","import { SchemaAbiType, arrayAbiTypeToStaticAbiType, isArrayAbiType } from \"@latticexyz/schema-type\";\nimport { AbiParameterToPrimitiveType } from \"abitype\";\nimport { Hex, encodePacked } from \"viem\";\n\nexport function encodeField<TSchemaAbiType extends SchemaAbiType>(\n fieldType: TSchemaAbiType,\n value: AbiParameterToPrimitiveType<{ type: TSchemaAbiType }>,\n): Hex {\n if (isArrayAbiType(fieldType) && Array.isArray(value)) {\n const staticFieldType = arrayAbiTypeToStaticAbiType(fieldType);\n // TODO: we can remove conditional once this is fixed: https://github.com/wagmi-dev/viem/pull/1147\n return value.length === 0\n ? \"0x\"\n : encodePacked(\n value.map(() => staticFieldType),\n value,\n );\n }\n return encodePacked([fieldType], [value]);\n}\n","import { isStaticAbiType } from \"@latticexyz/schema-type\";\nimport { Hex } from \"viem\";\nimport { SchemaToPrimitives, KeySchema } from \"./common\";\nimport { encodeKeyTuple } from \"./encodeKeyTuple\";\n\nexport function encodeKey<TSchema extends KeySchema>(keySchema: TSchema, key: SchemaToPrimitives<TSchema>): Hex[] {\n const staticFields = Object.values(keySchema).filter(isStaticAbiType);\n // TODO: refactor and move all encodeKeyTuple logic into this method so we can delete encodeKeyTuple\n return encodeKeyTuple({ staticFields, dynamicFields: [] }, Object.values(key));\n}\n","import { StaticPrimitiveType } from \"@latticexyz/schema-type\";\nimport { Hex, encodeAbiParameters } from \"viem\";\nimport { Schema } from \"./common\";\n\n/** @deprecated use `encodeKey` instead */\nexport function encodeKeyTuple(keySchema: Schema, keyTuple: StaticPrimitiveType[]): Hex[] {\n return keyTuple.map((key, index) => encodeAbiParameters([{ type: keySchema.staticFields[index] }], [key]));\n}\n","import { StaticPrimitiveType, DynamicPrimitiveType } from \"@latticexyz/schema-type\";\nimport { Hex } from \"viem\";\nimport { encodeField } from \"./encodeField\";\nimport { Schema } from \"./common\";\n\n/** @deprecated use `encodeValue` instead */\nexport function encodeRecord(\n valueSchema: Schema,\n values: readonly (StaticPrimitiveType | DynamicPrimitiveType)[],\n): Hex {\n const staticValues = values.slice(0, valueSchema.staticFields.length) as readonly StaticPrimitiveType[];\n const dynamicValues = values.slice(valueSchema.staticFields.length) as readonly DynamicPrimitiveType[];\n\n const staticData = staticValues\n .map((value, i) => encodeField(valueSchema.staticFields[i], value).replace(/^0x/, \"\"))\n .join(\"\");\n\n if (valueSchema.dynamicFields.length === 0) return `0x${staticData}`;\n\n const dynamicDataItems = dynamicValues.map((value, i) =>\n encodeField(valueSchema.dynamicFields[i], value).replace(/^0x/, \"\"),\n );\n\n const dynamicFieldByteLengths = dynamicDataItems.map((value) => value.length / 2).reverse();\n const dynamicTotalByteLength = dynamicFieldByteLengths.reduce((total, length) => total + BigInt(length), 0n);\n\n const dynamicData = dynamicDataItems.join(\"\");\n\n const packedCounter = `${dynamicFieldByteLengths\n .map((length) => encodeField(\"uint40\", length).replace(/^0x/, \"\"))\n .join(\"\")}${encodeField(\"uint56\", dynamicTotalByteLength).replace(/^0x/, \"\")}`.padStart(64, \"0\");\n\n return `0x${staticData}${packedCounter}${dynamicData}`;\n}\n","import { Hex, concatHex } from \"viem\";\nimport { SchemaToPrimitives, ValueSchema } from \"./common\";\nimport { encodeValueArgs } from \"./encodeValueArgs\";\n\nexport function encodeValue<TSchema extends ValueSchema>(\n valueSchema: TSchema,\n value: SchemaToPrimitives<TSchema>,\n): Hex {\n const { staticData, encodedLengths, dynamicData } = encodeValueArgs(valueSchema, value);\n return concatHex([staticData, encodedLengths, dynamicData]);\n}\n","import {\n StaticPrimitiveType,\n DynamicPrimitiveType,\n isStaticAbiType,\n isDynamicAbiType,\n StaticAbiType,\n DynamicAbiType,\n} from \"@latticexyz/schema-type\";\nimport { concatHex } from \"viem\";\nimport { encodeField } from \"./encodeField\";\nimport { SchemaToPrimitives, ValueArgs, ValueSchema } from \"./common\";\nimport { encodeLengths } from \"./encodeLengths\";\n\nexport function encodeValueArgs<TSchema extends ValueSchema>(\n valueSchema: TSchema,\n value: SchemaToPrimitives<TSchema>,\n): ValueArgs {\n const valueSchemaEntries = Object.entries(valueSchema);\n const staticFields = valueSchemaEntries.filter(([, type]) => isStaticAbiType(type)) as [string, StaticAbiType][];\n const dynamicFields = valueSchemaEntries.filter(([, type]) => isDynamicAbiType(type)) as [string, DynamicAbiType][];\n // TODO: validate <=5 dynamic fields\n // TODO: validate <=28 total fields\n\n const encodedStaticValues = staticFields.map(([name, type]) => encodeField(type, value[name] as StaticPrimitiveType));\n const encodedDynamicValues = dynamicFields.map(([name, type]) =>\n encodeField(type, value[name] as DynamicPrimitiveType),\n );\n\n const encodedLengths = encodeLengths(encodedDynamicValues);\n\n return {\n staticData: concatHex(encodedStaticValues),\n encodedLengths,\n dynamicData: concatHex(encodedDynamicValues),\n };\n}\n","import { Hex, concatHex, padHex, size } from \"viem\";\nimport { encodeField } from \"./encodeField\";\n\nexport function encodeLengths(values: Hex[]): Hex {\n const byteLengths = values.map(size).reverse();\n const totalByteLength = byteLengths.reduce((total, length) => total + BigInt(length), 0n);\n\n return padHex(\n concatHex([...byteLengths.map((length) => encodeField(\"uint40\", length)), encodeField(\"uint56\", totalByteLength)]),\n { size: 32, dir: \"left\" },\n );\n}\n","import { Hex } from \"viem\";\nimport { FieldLayout } from \"./common\";\n\n/** @deprecated use `valueSchemaToFieldLayoutHex` instead */\nexport function fieldLayoutToHex(fieldLayout: FieldLayout): Hex {\n const staticDataLength = fieldLayout.staticFieldLengths.reduce((totalLength, length) => totalLength + length, 0);\n return `0x${[\n staticDataLength.toString(16).padStart(4, \"0\"),\n fieldLayout.staticFieldLengths.length.toString(16).padStart(2, \"0\"),\n fieldLayout.numDynamicFields.toString(16).padStart(2, \"0\"),\n ...fieldLayout.staticFieldLengths.map((schemaType) => schemaType.toString(16).padStart(2, \"0\")),\n ]\n .join(\"\")\n .padEnd(64, \"0\")}`;\n}\n","import { StaticAbiType, DynamicAbiType, schemaAbiTypes, staticAbiTypeToByteLength } from \"@latticexyz/schema-type\";\nimport { Hex, hexToNumber, sliceHex } from \"viem\";\nimport { Schema } from \"./common\";\nimport { InvalidHexLengthForSchemaError, SchemaStaticLengthMismatchError } from \"./errors\";\n\nexport function hexToSchema(data: Hex): Schema {\n if (data.length !== 66) {\n throw new InvalidHexLengthForSchemaError(data);\n }\n\n const staticDataLength = hexToNumber(sliceHex(data, 0, 2));\n const numStaticFields = hexToNumber(sliceHex(data, 2, 3));\n const numDynamicFields = hexToNumber(sliceHex(data, 3, 4));\n const staticFields: StaticAbiType[] = [];\n const dynamicFields: DynamicAbiType[] = [];\n\n for (let i = 4; i < 4 + numStaticFields; i++) {\n const schemaTypeIndex = hexToNumber(sliceHex(data, i, i + 1));\n staticFields.push(schemaAbiTypes[schemaTypeIndex] as StaticAbiType);\n }\n for (let i = 4 + numStaticFields; i < 4 + numStaticFields + numDynamicFields; i++) {\n const schemaTypeIndex = hexToNumber(sliceHex(data, i, i + 1));\n dynamicFields.push(schemaAbiTypes[schemaTypeIndex] as DynamicAbiType);\n }\n\n // validate static data length\n const actualStaticDataLength = staticFields.reduce((acc, fieldType) => acc + staticAbiTypeToByteLength[fieldType], 0);\n if (actualStaticDataLength !== staticDataLength) {\n console.warn(\n `Schema \"${data}\" static data length (${staticDataLength}) did not match the summed length of all static fields (${actualStaticDataLength}). ` +\n `Is \\`staticAbiTypeToByteLength\\` up to date with Solidity schema types?`,\n );\n throw new SchemaStaticLengthMismatchError(data, staticDataLength, actualStaticDataLength);\n }\n\n return { staticFields, dynamicFields };\n}\n","import { Hex, sliceHex } from \"viem\";\nimport { TableSchema } from \"./common\";\nimport { hexToSchema } from \"./hexToSchema\";\n\nexport function hexToTableSchema(data: Hex): TableSchema {\n const valueSchema = hexToSchema(sliceHex(data, 0, 32));\n const keySchema = hexToSchema(sliceHex(data, 32, 64));\n return {\n keySchema,\n valueSchema,\n };\n}\n","import { isStaticAbiType } from \"@latticexyz/schema-type\";\nimport { Hex } from \"viem\";\nimport { KeySchema } from \"./common\";\nimport { schemaToHex } from \"./schemaToHex\";\n\nexport function keySchemaToHex(keySchema: KeySchema): Hex {\n return schemaToHex({ staticFields: Object.values(keySchema).filter(isStaticAbiType), dynamicFields: [] });\n}\n","import { schemaAbiTypes } from \"@latticexyz/schema-type\";\nimport { Hex } from \"viem\";\nimport { Schema } from \"./common\";\nimport { staticDataLength } from \"./staticDataLength\";\n\n/** @deprecated use `keySchemaToHex` or `valueSchemaToHex` instead */\nexport function schemaToHex(schema: Schema): Hex {\n const staticSchemaTypes = schema.staticFields.map((abiType) => schemaAbiTypes.indexOf(abiType));\n const dynamicSchemaTypes = schema.dynamicFields.map((abiType) => schemaAbiTypes.indexOf(abiType));\n return `0x${[\n staticDataLength(schema.staticFields).toString(16).padStart(4, \"0\"),\n schema.staticFields.length.toString(16).padStart(2, \"0\"),\n schema.dynamicFields.length.toString(16).padStart(2, \"0\"),\n ...staticSchemaTypes.map((schemaType) => schemaType.toString(16).padStart(2, \"0\")),\n ...dynamicSchemaTypes.map((schemaType) => schemaType.toString(16).padStart(2, \"0\")),\n ]\n .join(\"\")\n .padEnd(64, \"0\")}`;\n}\n","import { SchemaAbiType } from \"@latticexyz/schema-type\";\nimport { Schema } from \"./common\";\n\nexport function schemaIndexToAbiType(schema: Schema, schemaIndex: number): SchemaAbiType {\n if (schemaIndex < schema.staticFields.length) {\n return schema.staticFields[schemaIndex];\n }\n return schema.dynamicFields[schemaIndex - schema.staticFields.length];\n}\n","import { Hex } from \"viem\";\nimport { ValueSchema } from \"./common\";\nimport { isDynamicAbiType, isStaticAbiType, staticAbiTypeToByteLength } from \"@latticexyz/schema-type\";\n\n// TODO: add tests once we have corresponding tests for FieldLayout.sol (bytes32 -> FieldLayout and vice versa)\nexport function valueSchemaToFieldLayoutHex(valueSchema: ValueSchema): Hex {\n const staticFields = Object.values(valueSchema).filter(isStaticAbiType);\n const dynamicFields = Object.values(valueSchema).filter(isDynamicAbiType);\n\n const staticFieldLengths = staticFields.map((fieldType) => staticAbiTypeToByteLength[fieldType]);\n const staticDataLength = staticFieldLengths.reduce((dataLength, fieldLength) => dataLength + fieldLength, 0);\n\n return `0x${[\n staticDataLength.toString(16).padStart(4, \"0\"),\n staticFields.length.toString(16).padStart(2, \"0\"),\n dynamicFields.length.toString(16).padStart(2, \"0\"),\n ...staticFieldLengths.map((fieldLength) => fieldLength.toString(16).padStart(2, \"0\")),\n ]\n .join(\"\")\n .padEnd(64, \"0\")}`;\n}\n","import { isDynamicAbiType, isStaticAbiType } from \"@latticexyz/schema-type\";\nimport { Hex } from \"viem\";\nimport { ValueSchema } from \"./common\";\nimport { schemaToHex } from \"./schemaToHex\";\n\nexport function valueSchemaToHex(valueSchema: ValueSchema): Hex {\n return schemaToHex({\n staticFields: Object.values(valueSchema).filter(isStaticAbiType),\n dynamicFields: Object.values(valueSchema).filter(isDynamicAbiType),\n });\n}\n"],"mappings":"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","names":["isDynamicAbiType","abiTypesToSchema","abiTypes","staticFields","dynamicFields","abiType","hexToString","sliceHex","assertExhaustive","arrayAbiTypeToStaticAbiType","staticAbiTypeToByteLength","getAddress","hexToBigInt","hexToBool","assertExhaustive","staticAbiTypeToByteLength","staticAbiTypeToDefaultValue","MUDError","staticAbiTypeToByteLength","InvalidHexLengthError","value","InvalidHexLengthForSchemaError","InvalidHexLengthForPackedCounterError","InvalidHexLengthForStaticFieldError","abiType","InvalidHexLengthForArrayFieldError","SchemaStaticLengthMismatchError","schemaData","definedLength","summedLength","PackedCounterLengthMismatchError","packedCounterData","decodeStaticField","abiType","data","InvalidHexLengthError","staticAbiTypeToByteLength","InvalidHexLengthForStaticFieldError","value","hexToBigInt","defaultValueType","staticAbiTypeToDefaultValue","hexToBool","getAddress","assertExhaustive","decodeDynamicField","abiType","data","hexToString","InvalidHexLengthError","dataSize","staticAbiType","arrayAbiTypeToStaticAbiType","itemByteLength","staticAbiTypeToByteLength","InvalidHexLengthForArrayFieldError","_","i","itemData","sliceHex","decodeStaticField","assertExhaustive","isDynamicAbiType","decodeField","abiType","data","isDynamicAbiType","decodeDynamicField","decodeStaticField","decodeAbiParameters","decodeKeyTuple","keySchema","keyTuple","key","index","decodeKey","keySchema","data","keyValues","decodeKeyTuple","name","i","staticAbiTypeToByteLength","dynamicAbiTypeToDefaultValue","readHex","hexToPackedCounter","data","InvalidHexLengthForPackedCounterError","totalByteLength","decodeStaticField","reversedFieldByteLengths","decodeDynamicField","fieldByteLengths","summedLength","total","length","PackedCounterLengthMismatchError","staticAbiTypeToByteLength","staticDataLength","staticFields","length","fieldType","readHex","decodeRecord","valueSchema","data","values","bytesOffset","fieldType","fieldByteLength","staticAbiTypeToByteLength","value","decodeStaticField","schemaStaticDataLength","staticDataLength","actualStaticDataLength","dataLayout","hexToPackedCounter","i","dataLength","decodeDynamicField","dynamicAbiTypeToDefaultValue","actualDynamicDataLength","isStaticAbiType","isDynamicAbiType","decodeValue","valueSchema","data","staticFields","isStaticAbiType","dynamicFields","isDynamicAbiType","valueTuple","decodeRecord","name","i","concatHex","isStaticAbiType","readHex","decodeValueArgs","valueSchema","staticData","encodedLengths","dynamicData","decodeValue","concatHex","staticDataLength","isStaticAbiType","arrayAbiTypeToStaticAbiType","isArrayAbiType","encodePacked","encodeField","fieldType","value","staticFieldType","isStaticAbiType","encodeAbiParameters","encodeKeyTuple","keySchema","keyTuple","key","index","encodeKey","keySchema","key","staticFields","isStaticAbiType","encodeKeyTuple","encodeRecord","valueSchema","values","staticValues","dynamicValues","staticData","value","i","encodeField","dynamicDataItems","dynamicFieldByteLengths","dynamicTotalByteLength","total","length","dynamicData","packedCounter","concatHex","isStaticAbiType","isDynamicAbiType","concatHex","concatHex","padHex","size","encodeLengths","values","byteLengths","size","totalByteLength","total","length","padHex","concatHex","encodeField","encodeValueArgs","valueSchema","value","valueSchemaEntries","staticFields","type","isStaticAbiType","dynamicFields","isDynamicAbiType","encodedStaticValues","name","encodeField","encodedDynamicValues","encodedLengths","encodeLengths","concatHex","encodeValue","valueSchema","value","staticData","encodedLengths","dynamicData","encodeValueArgs","concatHex","fieldLayoutToHex","fieldLayout","totalLength","length","schemaType","schemaAbiTypes","staticAbiTypeToByteLength","hexToNumber","sliceHex","hexToSchema","data","InvalidHexLengthForSchemaError","staticDataLength","hexToNumber","sliceHex","numStaticFields","numDynamicFields","staticFields","dynamicFields","i","schemaTypeIndex","schemaAbiTypes","actualStaticDataLength","acc","fieldType","staticAbiTypeToByteLength","SchemaStaticLengthMismatchError","sliceHex","hexToTableSchema","data","valueSchema","hexToSchema","sliceHex","isStaticAbiType","schemaAbiTypes","schemaToHex","schema","staticSchemaTypes","abiType","schemaAbiTypes","dynamicSchemaTypes","staticDataLength","schemaType","keySchemaToHex","keySchema","schemaToHex","isStaticAbiType","schemaIndexToAbiType","schema","schemaIndex","isDynamicAbiType","isStaticAbiType","staticAbiTypeToByteLength","valueSchemaToFieldLayoutHex","valueSchema","staticFields","dynamicFields","staticFieldLengths","fieldType","dataLength","fieldLength","isDynamicAbiType","isStaticAbiType","valueSchemaToHex","valueSchema","schemaToHex","isStaticAbiType","isDynamicAbiType"]}
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@latticexyz/protocol-parser",
3
- "version": "2.0.0-main-3042f86e",
3
+ "version": "2.0.0-main-db314a74",
4
4
  "description": "Parser utilities for the MUD protocol",
5
5
  "repository": {
6
6
  "type": "git",
@@ -16,8 +16,8 @@
16
16
  "dependencies": {
17
17
  "abitype": "1.0.0",
18
18
  "viem": "2.7.12",
19
- "@latticexyz/common": "2.0.0-main-3042f86e",
20
- "@latticexyz/schema-type": "2.0.0-main-3042f86e"
19
+ "@latticexyz/common": "2.0.0-main-db314a74",
20
+ "@latticexyz/schema-type": "2.0.0-main-db314a74"
21
21
  },
22
22
  "devDependencies": {
23
23
  "tsup": "^6.7.0",
package/src/decodeDynamicField.test.ts CHANGED
@@ -22,28 +22,28 @@ describe("decodeDynamicField", () => {
22
22
 
23
23
  it("can decode uint256[]", () => {
24
24
  expect(
25
- decodeDynamicField("uint256[]", "0x0000000000000000000000000000000000000000000000000000000000000000")
25
+ decodeDynamicField("uint256[]", "0x0000000000000000000000000000000000000000000000000000000000000000"),
26
26
  ).toStrictEqual([0n]);
27
27
  expect(
28
- decodeDynamicField("uint256[]", "0x0000000000000000000000000000000000000000000000000000000000000001")
28
+ decodeDynamicField("uint256[]", "0x0000000000000000000000000000000000000000000000000000000000000001"),
29
29
  ).toStrictEqual([1n]);
30
30
  expect(
31
- decodeDynamicField("uint256[]", "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")
31
+ decodeDynamicField("uint256[]", "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"),
32
32
  ).toStrictEqual([115792089237316195423570985008687907853269984665640564039457584007913129639935n]);
33
33
  expect(
34
- decodeDynamicField("uint256[]", "0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe")
34
+ decodeDynamicField("uint256[]", "0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe"),
35
35
  ).toStrictEqual([115792089237316195423570985008687907853269984665640564039457584007913129639934n]);
36
36
  expect(
37
37
  decodeDynamicField(
38
38
  "uint256[]",
39
- "0x00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000001"
40
- )
39
+ "0x00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000001",
40
+ ),
41
41
  ).toStrictEqual([1n, 1n]);
42
42
  expect(
43
43
  decodeDynamicField(
44
44
  "uint256[]",
45
- "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
46
- )
45
+ "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
46
+ ),
47
47
  ).toStrictEqual([
48
48
  115792089237316195423570985008687907853269984665640564039457584007913129639935n,
49
49
  115792089237316195423570985008687907853269984665640564039457584007913129639935n,
@@ -68,41 +68,41 @@ describe("decodeDynamicField", () => {
68
68
 
69
69
  it("can decode int256[]", () => {
70
70
  expect(
71
- decodeDynamicField("int256[]", "0x0000000000000000000000000000000000000000000000000000000000000000")
71
+ decodeDynamicField("int256[]", "0x0000000000000000000000000000000000000000000000000000000000000000"),
72
72
  ).toStrictEqual([0n]);
73
73
  expect(
74
- decodeDynamicField("int256[]", "0x0000000000000000000000000000000000000000000000000000000000000001")
74
+ decodeDynamicField("int256[]", "0x0000000000000000000000000000000000000000000000000000000000000001"),
75
75
  ).toStrictEqual([1n]);
76
76
  expect(
77
- decodeDynamicField("int256[]", "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")
77
+ decodeDynamicField("int256[]", "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"),
78
78
  ).toStrictEqual([57896044618658097711785492504343953926634992332820282019728792003956564819967n]);
79
79
  expect(
80
- decodeDynamicField("int256[]", "0x8000000000000000000000000000000000000000000000000000000000000000")
80
+ decodeDynamicField("int256[]", "0x8000000000000000000000000000000000000000000000000000000000000000"),
81
81
  ).toStrictEqual([-57896044618658097711785492504343953926634992332820282019728792003956564819968n]);
82
82
  expect(
83
- decodeDynamicField("int256[]", "0x8000000000000000000000000000000000000000000000000000000000000001")
83
+ decodeDynamicField("int256[]", "0x8000000000000000000000000000000000000000000000000000000000000001"),
84
84
  ).toStrictEqual([-57896044618658097711785492504343953926634992332820282019728792003956564819967n]);
85
85
  expect(
86
- decodeDynamicField("int256[]", "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")
86
+ decodeDynamicField("int256[]", "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"),
87
87
  ).toStrictEqual([-1n]);
88
88
 
89
89
  expect(
90
90
  decodeDynamicField(
91
91
  "int256[]",
92
- "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
93
- )
92
+ "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
93
+ ),
94
94
  ).toStrictEqual([57896044618658097711785492504343953926634992332820282019728792003956564819967n, -1n]);
95
95
  expect(
96
96
  decodeDynamicField(
97
97
  "int256[]",
98
- "0x80000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
99
- )
98
+ "0x80000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
99
+ ),
100
100
  ).toStrictEqual([-57896044618658097711785492504343953926634992332820282019728792003956564819968n, 0n]);
101
101
  expect(
102
102
  decodeDynamicField(
103
103
  "int256[]",
104
- "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff8000000000000000000000000000000000000000000000000000000000000001"
105
- )
104
+ "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff8000000000000000000000000000000000000000000000000000000000000001",
105
+ ),
106
106
  ).toStrictEqual([-1n, -57896044618658097711785492504343953926634992332820282019728792003956564819967n]);
107
107
  });
108
108
 
@@ -129,13 +129,13 @@ describe("decodeDynamicField", () => {
129
129
  ]);
130
130
  expect(decodeDynamicField("bytes4[]", "0xff00ff00ff00ff00")).toStrictEqual(["0xff00ff00", "0xff00ff00"]);
131
131
  expect(
132
- decodeDynamicField("bytes32[]", "0x0000000000000000000000000000000000000000000000000000000000000001")
132
+ decodeDynamicField("bytes32[]", "0x0000000000000000000000000000000000000000000000000000000000000001"),
133
133
  ).toStrictEqual(["0x0000000000000000000000000000000000000000000000000000000000000001"]);
134
134
  expect(
135
135
  decodeDynamicField(
136
136
  "bytes32[]",
137
- "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001"
138
- )
137
+ "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001",
138
+ ),
139
139
  ).toStrictEqual([
140
140
  "0x0000000000000000000000000000000000000000000000000000000000000000",
141
141
  "0x0000000000000000000000000000000000000000000000000000000000000001",
@@ -151,10 +151,10 @@ describe("decodeDynamicField", () => {
151
151
  ]);
152
152
 
153
153
  expect(() => decodeDynamicField("address[]", "0x00")).toThrow(
154
- 'Hex value "0x00" has length of 2, but expected a multiple of 40 for address[] type.'
154
+ 'Hex value "0x00" has length of 2, but expected a multiple of 40 for address[] type.',
155
155
  );
156
156
  expect(() => decodeDynamicField("address[]", "0xffffffffffffffffffffffffffffffffffffffffff")).toThrow(
157
- 'Hex value "0xffffffffffffffffffffffffffffffffffffffffff" has length of 42, but expected a multiple of 40 for address[] type.'
157
+ 'Hex value "0xffffffffffffffffffffffffffffffffffffffffff" has length of 42, but expected a multiple of 40 for address[] type.',
158
158
  );
159
159
  });
160
160
 
@@ -164,7 +164,7 @@ describe("decodeDynamicField", () => {
164
164
  expect(decodeDynamicField("bytes", "0x0001")).toBe("0x0001");
165
165
  expect(decodeDynamicField("bytes", "0xff00ff00ff00ff00")).toBe("0xff00ff00ff00ff00");
166
166
  expect(decodeDynamicField("bytes", "0x0000000000000000000000000000000000000000000000000000000000000001")).toBe(
167
- "0x0000000000000000000000000000000000000000000000000000000000000001"
167
+ "0x0000000000000000000000000000000000000000000000000000000000000001",
168
168
  );
169
169
  });
170
170
 
package/src/decodeDynamicField.ts CHANGED
@@ -14,7 +14,7 @@ import { InvalidHexLengthError, InvalidHexLengthForArrayFieldError } from "./err
14
14
 
15
15
  export function decodeDynamicField<
16
16
  TAbiType extends DynamicAbiType,
17
- TPrimitiveType extends DynamicAbiTypeToPrimitiveType<TAbiType>
17
+ TPrimitiveType extends DynamicAbiTypeToPrimitiveType<TAbiType>,
18
18
  >(abiType: TAbiType, data: Hex): TPrimitiveType {
19
19
  if (abiType === "bytes") {
20
20
  return data as TPrimitiveType;
package/src/decodeField.ts CHANGED
@@ -5,7 +5,7 @@ import { decodeStaticField } from "./decodeStaticField";
5
5
 
6
6
  export function decodeField<
7
7
  TAbiType extends SchemaAbiType,
8
- TPrimitiveType extends SchemaAbiTypeToPrimitiveType<TAbiType>
8
+ TPrimitiveType extends SchemaAbiTypeToPrimitiveType<TAbiType>,
9
9
  >(abiType: TAbiType, data: Hex): TPrimitiveType {
10
10
  return (
11
11
  isDynamicAbiType(abiType) ? decodeDynamicField(abiType, data) : decodeStaticField(abiType, data)
package/src/decodeKey.ts CHANGED
@@ -4,12 +4,12 @@ import { decodeKeyTuple } from "./decodeKeyTuple";
4
4
 
5
5
  export function decodeKey<TSchema extends KeySchema>(
6
6
  keySchema: TSchema,
7
- data: readonly Hex[]
7
+ data: readonly Hex[],
8
8
  ): SchemaToPrimitives<TSchema> {
9
9
  // TODO: refactor and move all decodeKeyTuple logic into this method so we can delete decodeKeyTuple
10
10
  const keyValues = decodeKeyTuple({ staticFields: Object.values(keySchema), dynamicFields: [] }, data);
11
11
 
12
12
  return Object.fromEntries(
13
- Object.keys(keySchema).map((name, i) => [name, keyValues[i]])
13
+ Object.keys(keySchema).map((name, i) => [name, keyValues[i]]),
14
14
  ) as SchemaToPrimitives<TSchema>;
15
15
  }
package/src/decodeKeyTuple.test.ts CHANGED
@@ -6,12 +6,12 @@ describe("decodeKeyTuple", () => {
6
6
  expect(
7
7
  decodeKeyTuple({ staticFields: ["bool"], dynamicFields: [] }, [
8
8
  "0x0000000000000000000000000000000000000000000000000000000000000000",
9
- ])
9
+ ]),
10
10
  ).toStrictEqual([false]);
11
11
  expect(
12
12
  decodeKeyTuple({ staticFields: ["bool"], dynamicFields: [] }, [
13
13
  "0x0000000000000000000000000000000000000000000000000000000000000001",
14
- ])
14
+ ]),
15
15
  ).toStrictEqual([true]);
16
16
  });
17
17
 
@@ -24,7 +24,7 @@ describe("decodeKeyTuple", () => {
24
24
  "0x000000000000000000000000ffffffffffffffffffffffffffffffffffffffff",
25
25
  "0x0000000000000000000000000000000000000000000000000000000000000001",
26
26
  "0x0000000000000000000000000000000000000000000000000000000000000003",
27
- ])
27
+ ]),
28
28
  ).toStrictEqual([
29
29
  42n,
30
30
  -42,
package/src/decodeKeyTuple.ts CHANGED
@@ -8,10 +8,10 @@ import { Schema } from "./common";
8
8
  export function decodeKeyTuple(keySchema: Schema, keyTuple: readonly Hex[]): StaticPrimitiveType[] {
9
9
  if (keySchema.staticFields.length !== keyTuple.length) {
10
10
  throw new Error(
11
- `key tuple length ${keyTuple.length} does not match key schema length ${keySchema.staticFields.length}`
11
+ `key tuple length ${keyTuple.length} does not match key schema length ${keySchema.staticFields.length}`,
12
12
  );
13
13
  }
14
14
  return keyTuple.map(
15
- (key, index) => decodeAbiParameters([{ type: keySchema.staticFields[index] }], key)[0] as StaticPrimitiveType
15
+ (key, index) => decodeAbiParameters([{ type: keySchema.staticFields[index] }], key)[0] as StaticPrimitiveType,
16
16
  );
17
17
  }
package/src/decodeRecord.test.ts CHANGED
@@ -6,7 +6,7 @@ describe("decodeRecord", () => {
6
6
  const valueSchema = { staticFields: ["uint32", "uint128"], dynamicFields: ["uint32[]", "string"] } as const;
7
7
  const values = decodeRecord(
8
8
  valueSchema,
9
- "0x0000000100000000000000000000000000000002000000000000000000000000000000000000000b0000000008000000000000130000000300000004736f6d6520737472696e67"
9
+ "0x0000000100000000000000000000000000000002000000000000000000000000000000000000000b0000000008000000000000130000000300000004736f6d6520737472696e67",
10
10
  );
11
11
  expect(values).toStrictEqual([1, 2n, [3, 4], "some string"]);
12
12
  });
package/src/decodeRecord.ts CHANGED
@@ -34,7 +34,7 @@ export function decodeRecord(valueSchema: Schema, data: Hex): readonly (StaticPr
34
34
  expectedLength: schemaStaticDataLength,
35
35
  actualLength: actualStaticDataLength,
36
36
  bytesOffset,
37
- }
37
+ },
38
38
  );
39
39
  }
40
40
 
@@ -63,7 +63,7 @@ export function decodeRecord(valueSchema: Schema, data: Hex): readonly (StaticPr
63
63
  expectedLength: dataLayout.totalByteLength,
64
64
  actualLength: actualDynamicDataLength,
65
65
  bytesOffset,
66
- }
66
+ },
67
67
  );
68
68
  }
69
69
  }
package/src/decodeStaticField.test.ts CHANGED
@@ -7,22 +7,22 @@ describe("decodeStaticField", () => {
7
7
  expect(decodeStaticField("bool", "0x01")).toBe(true);
8
8
 
9
9
  expect(() => decodeStaticField("bool", "0x0")).toThrow(
10
- 'Hex value "0x0" has length of 1, but expected length of 2 for bool type.'
10
+ 'Hex value "0x0" has length of 1, but expected length of 2 for bool type.',
11
11
  );
12
12
  expect(() => decodeStaticField("bool", "0x1")).toThrow(
13
- 'Hex value "0x1" has length of 1, but expected length of 2 for bool type.'
13
+ 'Hex value "0x1" has length of 1, but expected length of 2 for bool type.',
14
14
  );
15
15
  expect(() => decodeStaticField("bool", "0x000")).toThrow(
16
- 'Hex value "0x000" is an odd length (3). It must be an even length.'
16
+ 'Hex value "0x000" is an odd length (3). It must be an even length.',
17
17
  );
18
18
  expect(() => decodeStaticField("bool", "0x001")).toThrow(
19
- 'Hex value "0x001" is an odd length (3). It must be an even length.'
19
+ 'Hex value "0x001" is an odd length (3). It must be an even length.',
20
20
  );
21
21
  expect(() => decodeStaticField("bool", "0x0000")).toThrow(
22
- 'Hex value "0x0000" has length of 4, but expected length of 2 for bool type.'
22
+ 'Hex value "0x0000" has length of 4, but expected length of 2 for bool type.',
23
23
  );
24
24
  expect(() => decodeStaticField("bool", "0x0001")).toThrow(
25
- 'Hex value "0x0001" has length of 4, but expected length of 2 for bool type.'
25
+ 'Hex value "0x0001" has length of 4, but expected length of 2 for bool type.',
26
26
  );
27
27
  });
28
28
 
@@ -36,10 +36,10 @@ describe("decodeStaticField", () => {
36
36
  expect(decodeStaticField("uint256", "0x0000000000000000000000000000000000000000000000000000000000000000")).toBe(0n);
37
37
  expect(decodeStaticField("uint256", "0x0000000000000000000000000000000000000000000000000000000000000001")).toBe(1n);
38
38
  expect(decodeStaticField("uint256", "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")).toBe(
39
- 115792089237316195423570985008687907853269984665640564039457584007913129639935n
39
+ 115792089237316195423570985008687907853269984665640564039457584007913129639935n,
40
40
  );
41
41
  expect(decodeStaticField("uint256", "0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe")).toBe(
42
- 115792089237316195423570985008687907853269984665640564039457584007913129639934n
42
+ 115792089237316195423570985008687907853269984665640564039457584007913129639934n,
43
43
  );
44
44
  });
45
45
 
@@ -56,13 +56,13 @@ describe("decodeStaticField", () => {
56
56
  expect(decodeStaticField("int256", "0x0000000000000000000000000000000000000000000000000000000000000000")).toBe(0n);
57
57
  expect(decodeStaticField("int256", "0x0000000000000000000000000000000000000000000000000000000000000001")).toBe(1n);
58
58
  expect(decodeStaticField("int256", "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")).toBe(
59
- 57896044618658097711785492504343953926634992332820282019728792003956564819967n
59
+ 57896044618658097711785492504343953926634992332820282019728792003956564819967n,
60
60
  );
61
61
  expect(decodeStaticField("int256", "0x8000000000000000000000000000000000000000000000000000000000000000")).toBe(
62
- -57896044618658097711785492504343953926634992332820282019728792003956564819968n
62
+ -57896044618658097711785492504343953926634992332820282019728792003956564819968n,
63
63
  );
64
64
  expect(decodeStaticField("int256", "0x8000000000000000000000000000000000000000000000000000000000000001")).toBe(
65
- -57896044618658097711785492504343953926634992332820282019728792003956564819967n
65
+ -57896044618658097711785492504343953926634992332820282019728792003956564819967n,
66
66
  );
67
67
  expect(decodeStaticField("int256", "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")).toBe(-1n);
68
68
  });
@@ -72,23 +72,23 @@ describe("decodeStaticField", () => {
72
72
  expect(decodeStaticField("bytes2", "0x0001")).toBe("0x0001");
73
73
  expect(decodeStaticField("bytes8", "0xff00ff00ff00ff00")).toBe("0xff00ff00ff00ff00");
74
74
  expect(decodeStaticField("bytes32", "0x0000000000000000000000000000000000000000000000000000000000000001")).toBe(
75
- "0x0000000000000000000000000000000000000000000000000000000000000001"
75
+ "0x0000000000000000000000000000000000000000000000000000000000000001",
76
76
  );
77
77
  });
78
78
 
79
79
  it("can decode address", () => {
80
80
  expect(decodeStaticField("address", "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266")).toBe(
81
- "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266"
81
+ "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
82
82
  );
83
83
  expect(decodeStaticField("address", "0xffffffffffffffffffffffffffffffffffffffff")).toBe(
84
- "0xFFfFfFffFFfffFFfFFfFFFFFffFFFffffFfFFFfF"
84
+ "0xFFfFfFffFFfffFFfFFfFFFFFffFFFffffFfFFFfF",
85
85
  );
86
86
 
87
87
  expect(() => decodeStaticField("address", "0x00")).toThrow(
88
- 'Hex value "0x00" has length of 2, but expected length of 40 for address type.'
88
+ 'Hex value "0x00" has length of 2, but expected length of 40 for address type.',
89
89
  );
90
90
  expect(() => decodeStaticField("address", "0xffffffffffffffffffffffffffffffffffffffffff")).toThrow(
91
- 'Hex value "0xffffffffffffffffffffffffffffffffffffffffff" has length of 42, but expected length of 40 for address type.'
91
+ 'Hex value "0xffffffffffffffffffffffffffffffffffffffffff" has length of 42, but expected length of 40 for address type.',
92
92
  );
93
93
  });
94
94
  });
package/src/decodeStaticField.ts CHANGED
@@ -10,7 +10,7 @@ import { InvalidHexLengthError, InvalidHexLengthForStaticFieldError } from "./er
10
10
 
11
11
  export function decodeStaticField<
12
12
  TAbiType extends StaticAbiType,
13
- TPrimitiveType extends StaticAbiTypeToPrimitiveType<TAbiType>
13
+ TPrimitiveType extends StaticAbiTypeToPrimitiveType<TAbiType>,
14
14
  >(abiType: TAbiType, data: Hex): TPrimitiveType {
15
15
  if (data.length > 3 && data.length % 2 !== 0) {
16
16
  throw new InvalidHexLengthError(data);
package/src/decodeValue.ts CHANGED
@@ -11,6 +11,6 @@ export function decodeValue<TSchema extends ValueSchema>(valueSchema: TSchema, d
11
11
  const valueTuple = decodeRecord({ staticFields, dynamicFields }, data);
12
12
 
13
13
  return Object.fromEntries(
14
- Object.keys(valueSchema).map((name, i) => [name, valueTuple[i]])
14
+ Object.keys(valueSchema).map((name, i) => [name, valueTuple[i]]),
15
15
  ) as SchemaToPrimitives<TSchema>;
16
16
  }
package/src/decodeValueArgs.ts CHANGED
@@ -7,7 +7,7 @@ import { readHex } from "@latticexyz/common";
7
7
 
8
8
  export function decodeValueArgs<TSchema extends ValueSchema>(
9
9
  valueSchema: TSchema,
10
- { staticData, encodedLengths, dynamicData }: ValueArgs
10
+ { staticData, encodedLengths, dynamicData }: ValueArgs,
11
11
  ): SchemaToPrimitives<TSchema> {
12
12
  return decodeValue(
13
13
  valueSchema,
@@ -15,6 +15,6 @@ export function decodeValueArgs<TSchema extends ValueSchema>(
15
15
  readHex(staticData, 0, staticDataLength(Object.values(valueSchema).filter(isStaticAbiType))),
16
16
  encodedLengths,
17
17
  dynamicData,
18
- ])
18
+ ]),
19
19
  );
20
20
  }
package/src/encodeField.ts CHANGED
@@ -4,7 +4,7 @@ import { Hex, encodePacked } from "viem";
4
4
 
5
5
  export function encodeField<TSchemaAbiType extends SchemaAbiType>(
6
6
  fieldType: TSchemaAbiType,
7
- value: AbiParameterToPrimitiveType<{ type: TSchemaAbiType }>
7
+ value: AbiParameterToPrimitiveType<{ type: TSchemaAbiType }>,
8
8
  ): Hex {
9
9
  if (isArrayAbiType(fieldType) && Array.isArray(value)) {
10
10
  const staticFieldType = arrayAbiTypeToStaticAbiType(fieldType);
@@ -13,7 +13,7 @@ export function encodeField<TSchemaAbiType extends SchemaAbiType>(
13
13
  ? "0x"
14
14
  : encodePacked(
15
15
  value.map(() => staticFieldType),
16
- value
16
+ value,
17
17
  );
18
18
  }
19
19
  return encodePacked([fieldType], [value]);
package/src/encodeKeyTuple.test.ts CHANGED
@@ -12,8 +12,8 @@ describe("encodeKeyTuple", () => {
12
12
  staticFields: ["bool"],
13
13
  dynamicFields: [],
14
14
  },
15
- [true]
16
- )
15
+ [true],
16
+ ),
17
17
  ).toStrictEqual(["0x0000000000000000000000000000000000000000000000000000000000000001"]);
18
18
  });
19
19
 
@@ -26,7 +26,7 @@ describe("encodeKeyTuple", () => {
26
26
  "0xFFfFfFffFFfffFFfFFfFFFFFffFFFffffFfFFFfF",
27
27
  true,
28
28
  3,
29
- ])
29
+ ]),
30
30
  ).toStrictEqual([
31
31
  "0x000000000000000000000000000000000000000000000000000000000000002a",
32
32
  "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd6",
package/src/encodeLengths.test.ts CHANGED
@@ -4,13 +4,13 @@ import { encodeLengths } from "./encodeLengths";
4
4
  describe("encodeLengths", () => {
5
5
  it("can encode empty tuple", () => {
6
6
  expect(encodeLengths([])).toMatchInlineSnapshot(
7
- '"0x0000000000000000000000000000000000000000000000000000000000000000"'
7
+ '"0x0000000000000000000000000000000000000000000000000000000000000000"',
8
8
  );
9
9
  });
10
10
 
11
11
  it("can encode bool key tuple", () => {
12
12
  expect(encodeLengths(["0x1234", "0x12345678"])).toMatchInlineSnapshot(
13
- '"0x0000000000000000000000000000000000000004000000000200000000000006"'
13
+ '"0x0000000000000000000000000000000000000004000000000200000000000006"',
14
14
  );
15
15
  });
16
16
  });
package/src/encodeLengths.ts CHANGED
@@ -7,6 +7,6 @@ export function encodeLengths(values: Hex[]): Hex {
7
7
 
8
8
  return padHex(
9
9
  concatHex([...byteLengths.map((length) => encodeField("uint40", length)), encodeField("uint56", totalByteLength)]),
10
- { size: 32, dir: "left" }
10
+ { size: 32, dir: "left" },
11
11
  );
12
12
  }
package/src/encodeRecord.test.ts CHANGED
@@ -6,7 +6,7 @@ describe("encodeRecord", () => {
6
6
  const valueSchema = { staticFields: ["uint32", "uint128"], dynamicFields: ["uint32[]", "string"] } as const;
7
7
  const hex = encodeRecord(valueSchema, [1, 2n, [3, 4], "some string"]);
8
8
  expect(hex).toBe(
9
- "0x0000000100000000000000000000000000000002000000000000000000000000000000000000000b0000000008000000000000130000000300000004736f6d6520737472696e67"
9
+ "0x0000000100000000000000000000000000000002000000000000000000000000000000000000000b0000000008000000000000130000000300000004736f6d6520737472696e67",
10
10
  );
11
11
  });
12
12
 
package/src/encodeRecord.ts CHANGED
@@ -6,7 +6,7 @@ import { Schema } from "./common";
6
6
  /** @deprecated use `encodeValue` instead */
7
7
  export function encodeRecord(
8
8
  valueSchema: Schema,
9
- values: readonly (StaticPrimitiveType | DynamicPrimitiveType)[]
9
+ values: readonly (StaticPrimitiveType | DynamicPrimitiveType)[],
10
10
  ): Hex {
11
11
  const staticValues = values.slice(0, valueSchema.staticFields.length) as readonly StaticPrimitiveType[];
12
12
  const dynamicValues = values.slice(valueSchema.staticFields.length) as readonly DynamicPrimitiveType[];
@@ -18,7 +18,7 @@ export function encodeRecord(
18
18
  if (valueSchema.dynamicFields.length === 0) return `0x${staticData}`;
19
19
 
20
20
  const dynamicDataItems = dynamicValues.map((value, i) =>
21
- encodeField(valueSchema.dynamicFields[i], value).replace(/^0x/, "")
21
+ encodeField(valueSchema.dynamicFields[i], value).replace(/^0x/, ""),
22
22
  );
23
23
 
24
24
  const dynamicFieldByteLengths = dynamicDataItems.map((value) => value.length / 2).reverse();
package/src/encodeValue.ts CHANGED
@@ -4,7 +4,7 @@ import { encodeValueArgs } from "./encodeValueArgs";
4
4
 
5
5
  export function encodeValue<TSchema extends ValueSchema>(
6
6
  valueSchema: TSchema,
7
- value: SchemaToPrimitives<TSchema>
7
+ value: SchemaToPrimitives<TSchema>,
8
8
  ): Hex {
9
9
  const { staticData, encodedLengths, dynamicData } = encodeValueArgs(valueSchema, value);
10
10
  return concatHex([staticData, encodedLengths, dynamicData]);
package/src/encodeValueArgs.ts CHANGED
@@ -13,7 +13,7 @@ import { encodeLengths } from "./encodeLengths";
13
13
 
14
14
  export function encodeValueArgs<TSchema extends ValueSchema>(
15
15
  valueSchema: TSchema,
16
- value: SchemaToPrimitives<TSchema>
16
+ value: SchemaToPrimitives<TSchema>,
17
17
  ): ValueArgs {
18
18
  const valueSchemaEntries = Object.entries(valueSchema);
19
19
  const staticFields = valueSchemaEntries.filter(([, type]) => isStaticAbiType(type)) as [string, StaticAbiType][];
@@ -23,7 +23,7 @@ export function encodeValueArgs<TSchema extends ValueSchema>(
23
23
 
24
24
  const encodedStaticValues = staticFields.map(([name, type]) => encodeField(type, value[name] as StaticPrimitiveType));
25
25
  const encodedDynamicValues = dynamicFields.map(([name, type]) =>
26
- encodeField(type, value[name] as DynamicPrimitiveType)
26
+ encodeField(type, value[name] as DynamicPrimitiveType),
27
27
  );
28
28
 
29
29
  const encodedLengths = encodeLengths(encodedDynamicValues);
package/src/errors.ts CHANGED
@@ -29,7 +29,7 @@ export class InvalidHexLengthForStaticFieldError extends MUDError {
29
29
  super(
30
30
  `Hex value "${value}" has length of ${value.length - 2}, but expected length of ${
31
31
  staticAbiTypeToByteLength[abiType] * 2
32
- } for ${abiType} type.`
32
+ } for ${abiType} type.`,
33
33
  );
34
34
  }
35
35
  }
@@ -40,7 +40,7 @@ export class InvalidHexLengthForArrayFieldError extends MUDError {
40
40
  super(
41
41
  `Hex value "${value}" has length of ${value.length - 2}, but expected a multiple of ${
42
42
  staticAbiTypeToByteLength[abiType] * 2
43
- } for ${abiType}[] type.`
43
+ } for ${abiType}[] type.`,
44
44
  );
45
45
  }
46
46
  }
@@ -50,7 +50,7 @@ export class SchemaStaticLengthMismatchError extends MUDError {
50
50
  constructor(schemaData: Hex, definedLength: number, summedLength: number) {
51
51
  super(
52
52
  `Schema "${schemaData}" static data length (${definedLength}) did not match the summed length of all static fields (${summedLength}). ` +
53
- `Is \`staticAbiTypeToByteLength\` up to date with Solidity schema types?`
53
+ `Is \`staticAbiTypeToByteLength\` up to date with Solidity schema types?`,
54
54
  );
55
55
  }
56
56
  }
@@ -59,7 +59,7 @@ export class PackedCounterLengthMismatchError extends MUDError {
59
59
  override name = "PackedCounterLengthMismatchError";
60
60
  constructor(packedCounterData: Hex, definedLength: bigint, summedLength: bigint) {
61
61
  super(
62
- `PackedCounter "${packedCounterData}" total bytes length (${definedLength}) did not match the summed length of all field byte lengths (${summedLength}).`
62
+ `PackedCounter "${packedCounterData}" total bytes length (${definedLength}) did not match the summed length of all field byte lengths (${summedLength}).`,
63
63
  );
64
64
  }
65
65
  }
package/src/hexToPackedCounter.test.ts CHANGED
@@ -20,16 +20,16 @@ describe("hexToPackedCounter", () => {
20
20
 
21
21
  it("throws if schema hex data is not bytes32", () => {
22
22
  expect(() => hexToPackedCounter("0x01234")).toThrowErrorMatchingInlineSnapshot(
23
- '"Hex value \\"0x01234\\" has length of 5, but expected length of 64 for a packed counter."'
23
+ '"Hex value \\"0x01234\\" has length of 5, but expected length of 64 for a packed counter."',
24
24
  );
25
25
  });
26
26
 
27
27
  it("throws if packed counter total byte length doesn't match summed byte length of fields", () => {
28
28
  expect(() =>
29
- hexToPackedCounter("0x0000000000000000000000000000400000000020000000002000000000000040")
29
+ hexToPackedCounter("0x0000000000000000000000000000400000000020000000002000000000000040"),
30
30
  ).toThrowErrorMatchingInlineSnapshot(
31
31
  // eslint-disable-next-line max-len
32
- '"PackedCounter \\"0x0000000000000000000000000000400000000020000000002000000000000040\\" total bytes length (64) did not match the summed length of all field byte lengths (128)."'
32
+ '"PackedCounter \\"0x0000000000000000000000000000400000000020000000002000000000000040\\" total bytes length (64) did not match the summed length of all field byte lengths (128)."',
33
33
  );
34
34
  });
35
35
  });
package/src/hexToSchema.test.ts CHANGED
@@ -55,14 +55,14 @@ describe("hexToSchema", () => {
55
55
 
56
56
  it("throws if schema hex data is not bytes32", () => {
57
57
  expect(() => hexToSchema("0x002502045f2381c3c4c5")).toThrow(
58
- 'Hex value "0x002502045f2381c3c4c5" has length of 20, but expected length of 64 for a schema.'
58
+ 'Hex value "0x002502045f2381c3c4c5" has length of 20, but expected length of 64 for a schema.',
59
59
  );
60
60
  });
61
61
 
62
62
  it("throws if schema static field lengths do not match", () => {
63
63
  expect(() => hexToSchema("0x002502045f2381c3c4c500000000000000000000000000000000000000000000")).toThrow(
64
64
  // eslint-disable-next-line max-len
65
- 'Schema "0x002502045f2381c3c4c500000000000000000000000000000000000000000000" static data length (37) did not match the summed length of all static fields (36). Is `staticAbiTypeToByteLength` up to date with Solidity schema types?'
65
+ 'Schema "0x002502045f2381c3c4c500000000000000000000000000000000000000000000" static data length (37) did not match the summed length of all static fields (36). Is `staticAbiTypeToByteLength` up to date with Solidity schema types?',
66
66
  );
67
67
  });
68
68
  });
package/src/hexToSchema.ts CHANGED
@@ -28,7 +28,7 @@ export function hexToSchema(data: Hex): Schema {
28
28
  if (actualStaticDataLength !== staticDataLength) {
29
29
  console.warn(
30
30
  `Schema "${data}" static data length (${staticDataLength}) did not match the summed length of all static fields (${actualStaticDataLength}). ` +
31
- `Is \`staticAbiTypeToByteLength\` up to date with Solidity schema types?`
31
+ `Is \`staticAbiTypeToByteLength\` up to date with Solidity schema types?`,
32
32
  );
33
33
  throw new SchemaStaticLengthMismatchError(data, staticDataLength, actualStaticDataLength);
34
34
  }
package/src/schemaToHex.test.ts CHANGED
@@ -4,13 +4,13 @@ import { schemaToHex } from "./schemaToHex";
4
4
  describe("schemaToHex", () => {
5
5
  it("converts schema to hex", () => {
6
6
  expect(schemaToHex({ staticFields: ["bool"], dynamicFields: [] })).toBe(
7
- "0x0001010060000000000000000000000000000000000000000000000000000000"
7
+ "0x0001010060000000000000000000000000000000000000000000000000000000",
8
8
  );
9
9
  expect(schemaToHex({ staticFields: ["bool"], dynamicFields: ["bool[]"] })).toBe(
10
- "0x0001010160c20000000000000000000000000000000000000000000000000000"
10
+ "0x0001010160c20000000000000000000000000000000000000000000000000000",
11
11
  );
12
12
  expect(
13
- schemaToHex({ staticFields: ["bytes32", "int32"], dynamicFields: ["uint256[]", "address[]", "bytes", "string"] })
13
+ schemaToHex({ staticFields: ["bytes32", "int32"], dynamicFields: ["uint256[]", "address[]", "bytes", "string"] }),
14
14
  ).toBe("0x002402045f2381c3c4c500000000000000000000000000000000000000000000");
15
15
  });
16
16
  });