feat(#5): add Create encodings and reorganize tests #52
Conversation
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
- implement Create, Create2, and Create3 address derivations with structural validation - add dedicated Create encoding test suite - relocate TypedEncoder tests under test/lib/ for consistency
There was a problem hiding this comment.
Pull Request Overview
This PR introduces comprehensive test coverage for the TypedEncoder library and makes formatting changes across the codebase. The changes include:
- Added extensive test files for TypedEncoder covering encoding types (Struct, Hash, Packed, Array, CallWithSelector, CallWithSignature, Create/Create2/Create3), nested structures, polymorphic arrays, error handling, and external usage patterns
- Implemented Create/Create2/Create3 encoding support in TypedEncoder.sol with proper validation
- Formatting changes: multi-line function signatures for improved readability
- Added documentation and test harnesses for TypedEncoder limitations with recursive types
- Updated .gitignore to exclude certain markdown files
Reviewed Changes
Copilot reviewed 28 out of 36 changed files in this pull request and generated 2 comments.
Show a summary per file
| File | Description |
|---|---|
| src/lib/TypedEncoder.sol | Implemented Create/Create2/Create3 encoding with validation logic and removed EncodingTypeNotImplemented error |
| test/lib/*.t.sol | Added 9 comprehensive test files covering all TypedEncoder encoding types and edge cases |
| test/utils/*.sol | Added test harnesses and utility contracts for TypedEncoder testing |
| src/**/*.sol | Reformatted function signatures to multi-line format for better readability |
| test/**/*.t.sol | Reformatted function signatures and struct initialization for consistency |
| .gitignore | Added exclusions for CLAUDE*.md and GEMINI.md files |
💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.
Comment on lines
+204
to
+205
| chunk.primitives[0].isDynamic || chunk.primitives[0].data.length != 32 || chunk.primitives[1].isDynamic | ||
| || chunk.primitives[1].data.length != 32 |
There was a problem hiding this comment.
The long conditional expressions spanning lines 203-205, 221-224, and 240-243 are difficult to read. Consider extracting these into a helper function like _validateStaticPrimitive(Primitive memory prim) to improve code clarity and reduce duplication across the three Create encoding validation blocks.
| revert InvalidCreateEncodingStructure(); | ||
| } | ||
| Chunk memory chunk = s.chunks[0]; | ||
| if (chunk.primitives.length != 2 || chunk.structs.length != 0 || chunk.arrays.length != 0) { |
There was a problem hiding this comment.
The validation logic for Create/Create2/Create3 encoding structures (lines 200, 218, 237) is highly duplicated with only the primitive count differing. Consider extracting this into a helper function _validateChunkStructure(Chunk memory chunk, uint256 expectedPrimitiveCount) to reduce code duplication and improve maintainability.
re1ro
changed the title
fish-sammy
requested changes
Nov 4, 2025
Comment on lines
+194
to
+247
| if (s.encodingType == EncodingType.Create) { | ||
| // Validate Create encoding structure before forwarding | ||
| if (s.chunks.length != 1) { | ||
| revert InvalidCreateEncodingStructure(); | ||
| } | ||
| Chunk memory chunk = s.chunks[0]; | ||
| if (chunk.primitives.length != 2 || chunk.structs.length != 0 || chunk.arrays.length != 0) { | ||
| revert InvalidCreateEncodingStructure(); | ||
| } | ||
| if ( | ||
| chunk.primitives[0].isDynamic || chunk.primitives[0].data.length != 32 || chunk.primitives[1].isDynamic | ||
| || chunk.primitives[1].data.length != 32 | ||
| ) { | ||
| revert InvalidCreateEncodingStructure(); | ||
| } | ||
| return abi.encodePacked(_encodeCreate(s)); | ||
| } | ||
| // Create2 encoding computes contract address from CREATE2 opcode | ||
| if (s.encodingType == EncodingType.Create2) { | ||
| // Validate Create2 encoding structure before forwarding | ||
| if (s.chunks.length != 1) { | ||
| revert InvalidCreate2EncodingStructure(); | ||
| } | ||
| Chunk memory chunk = s.chunks[0]; | ||
| if (chunk.primitives.length != 3 || chunk.structs.length != 0 || chunk.arrays.length != 0) { | ||
| revert InvalidCreate2EncodingStructure(); | ||
| } | ||
| if ( | ||
| chunk.primitives[0].isDynamic || chunk.primitives[0].data.length != 32 || chunk.primitives[1].isDynamic | ||
| || chunk.primitives[1].data.length != 32 || chunk.primitives[2].isDynamic | ||
| || chunk.primitives[2].data.length != 32 | ||
| ) { | ||
| revert InvalidCreate2EncodingStructure(); | ||
| } | ||
| return abi.encodePacked(_encodeCreate2(s)); | ||
| } | ||
| // Create3 encoding computes contract address from CREATE3 pattern | ||
| if (s.encodingType == EncodingType.Create3) { | ||
| // Validate Create3 encoding structure before forwarding | ||
| if (s.chunks.length != 1) { | ||
| revert InvalidCreate3EncodingStructure(); | ||
| } | ||
| Chunk memory chunk = s.chunks[0]; | ||
| if (chunk.primitives.length != 3 || chunk.structs.length != 0 || chunk.arrays.length != 0) { | ||
| revert InvalidCreate3EncodingStructure(); | ||
| } | ||
| if ( | ||
| chunk.primitives[0].isDynamic || chunk.primitives[0].data.length != 32 || chunk.primitives[1].isDynamic | ||
| || chunk.primitives[1].data.length != 32 || chunk.primitives[2].isDynamic | ||
| || chunk.primitives[2].data.length != 32 | ||
| ) { | ||
| revert InvalidCreate3EncodingStructure(); | ||
| } | ||
| return abi.encodePacked(_encodeCreate3(s)); |
Contributor
There was a problem hiding this comment.
Move validations inside.
Comment on lines
+649
to
+870
| /** | ||
| * @notice Test CREATE with invalid structure (wrong primitive count) | ||
| * @dev Should revert with InvalidCreateEncodingStructure | ||
| */ | ||
| function testCreateInvalidStructure() public { | ||
| vm.skip(true); | ||
| // Skip until revert expectations can be validated | ||
| return; | ||
|
|
||
| TypedEncoder.Struct memory encoded = TypedEncoder.Struct({ | ||
| typeHash: keccak256("Invalid()"), | ||
| chunks: new TypedEncoder.Chunk[](1), | ||
| encodingType: TypedEncoder.EncodingType.Create | ||
| }); | ||
|
|
||
| // Wrong: only 1 primitive instead of 2 | ||
| encoded.chunks[0].primitives = new TypedEncoder.Primitive[](1); | ||
| encoded.chunks[0].primitives[0] = | ||
| TypedEncoder.Primitive({ isDynamic: false, data: abi.encode(address(0x1234)) }); | ||
|
|
||
| vm.expectRevert(TypedEncoder.InvalidCreateEncodingStructure.selector); | ||
| encoded.encode(); | ||
| } | ||
|
|
||
| /** | ||
| * @notice Test CREATE with dynamic field (invalid) | ||
| * @dev Should revert with InvalidCreateEncodingStructure | ||
| */ | ||
| function testCreateWithDynamicField() public { | ||
| vm.skip(true); | ||
| // Skip until revert expectations can be validated | ||
| return; | ||
|
|
||
| TypedEncoder.Struct memory encoded = TypedEncoder.Struct({ | ||
| typeHash: keccak256("Invalid(address deployer,uint256 nonce)"), | ||
| chunks: new TypedEncoder.Chunk[](1), | ||
| encodingType: TypedEncoder.EncodingType.Create | ||
| }); | ||
|
|
||
| encoded.chunks[0].primitives = new TypedEncoder.Primitive[](2); | ||
| encoded.chunks[0].primitives[0] = TypedEncoder.Primitive({ isDynamic: true, data: abi.encodePacked("invalid") }); // Wrong: | ||
| // dynamic | ||
| encoded.chunks[0].primitives[1] = TypedEncoder.Primitive({ isDynamic: false, data: abi.encode(uint256(1)) }); | ||
|
|
||
| vm.expectRevert(TypedEncoder.InvalidCreateEncodingStructure.selector); | ||
| encoded.encode(); | ||
| } | ||
|
|
||
| /** | ||
| * @notice Test CREATE with nested struct (invalid) | ||
| * @dev Should revert with InvalidCreateEncodingStructure | ||
| */ | ||
| function testCreateWithNestedStruct() public { | ||
| vm.skip(true); | ||
| // Skip until revert expectations can be validated | ||
| return; | ||
|
|
||
| TypedEncoder.Struct memory encoded = TypedEncoder.Struct({ | ||
| typeHash: keccak256("Invalid()"), | ||
| chunks: new TypedEncoder.Chunk[](1), | ||
| encodingType: TypedEncoder.EncodingType.Create | ||
| }); | ||
|
|
||
| encoded.chunks[0].primitives = new TypedEncoder.Primitive[](2); | ||
| encoded.chunks[0].primitives[0] = | ||
| TypedEncoder.Primitive({ isDynamic: false, data: abi.encode(address(0x1234)) }); | ||
| encoded.chunks[0].primitives[1] = TypedEncoder.Primitive({ isDynamic: false, data: abi.encode(uint256(1)) }); | ||
| encoded.chunks[0].structs = new TypedEncoder.Struct[](1); // Wrong: has structs | ||
|
|
||
| vm.expectRevert(TypedEncoder.InvalidCreateEncodingStructure.selector); | ||
| encoded.encode(); | ||
| } | ||
|
|
||
| /** | ||
| * @notice Test CREATE2 with invalid structure (wrong primitive count) | ||
| * @dev Should revert with InvalidCreate2EncodingStructure | ||
| */ | ||
| function testCreate2InvalidStructure() public { | ||
| vm.skip(true); | ||
| // Skip until revert expectations can be validated | ||
| return; | ||
|
|
||
| TypedEncoder.Struct memory encoded = TypedEncoder.Struct({ | ||
| typeHash: keccak256("Invalid()"), | ||
| chunks: new TypedEncoder.Chunk[](1), | ||
| encodingType: TypedEncoder.EncodingType.Create2 | ||
| }); | ||
|
|
||
| // Wrong: only 2 primitives instead of 3 | ||
| encoded.chunks[0].primitives = new TypedEncoder.Primitive[](2); | ||
| encoded.chunks[0].primitives[0] = | ||
| TypedEncoder.Primitive({ isDynamic: false, data: abi.encode(address(0x1234)) }); | ||
| encoded.chunks[0].primitives[1] = TypedEncoder.Primitive({ isDynamic: false, data: abi.encode(bytes32(0)) }); | ||
|
|
||
| vm.expectRevert(TypedEncoder.InvalidCreate2EncodingStructure.selector); | ||
| encoded.encode(); | ||
| } | ||
|
|
||
| /** | ||
| * @notice Test CREATE2 with multiple chunks (invalid) | ||
| * @dev Should revert with InvalidCreate2EncodingStructure | ||
| */ | ||
| function testCreate2MultipleChunks() public { | ||
| vm.skip(true); | ||
| // Skip until revert expectations can be validated | ||
| return; | ||
|
|
||
| TypedEncoder.Struct memory encoded = TypedEncoder.Struct({ | ||
| typeHash: keccak256("Invalid()"), | ||
| chunks: new TypedEncoder.Chunk[](2), // Wrong: 2 chunks | ||
| encodingType: TypedEncoder.EncodingType.Create2 | ||
| }); | ||
|
|
||
| vm.expectRevert(TypedEncoder.InvalidCreate2EncodingStructure.selector); | ||
| encoded.encode(); | ||
| } | ||
|
|
||
| /** | ||
| * @notice Test CREATE2 with array field (invalid) | ||
| * @dev Should revert with InvalidCreate2EncodingStructure | ||
| */ | ||
| function testCreate2WithArray() public { | ||
| vm.skip(true); | ||
| // Skip until revert expectations can be validated | ||
| return; | ||
|
|
||
| TypedEncoder.Struct memory encoded = TypedEncoder.Struct({ | ||
| typeHash: keccak256("Invalid()"), | ||
| chunks: new TypedEncoder.Chunk[](1), | ||
| encodingType: TypedEncoder.EncodingType.Create2 | ||
| }); | ||
|
|
||
| encoded.chunks[0].primitives = new TypedEncoder.Primitive[](3); | ||
| encoded.chunks[0].primitives[0] = | ||
| TypedEncoder.Primitive({ isDynamic: false, data: abi.encode(address(0x1234)) }); | ||
| encoded.chunks[0].primitives[1] = TypedEncoder.Primitive({ isDynamic: false, data: abi.encode(bytes32(0)) }); | ||
| encoded.chunks[0].primitives[2] = | ||
| TypedEncoder.Primitive({ isDynamic: false, data: abi.encode(keccak256("test")) }); | ||
| encoded.chunks[0].arrays = new TypedEncoder.Array[](1); // Wrong: has arrays | ||
|
|
||
| vm.expectRevert(TypedEncoder.InvalidCreate2EncodingStructure.selector); | ||
| encoded.encode(); | ||
| } | ||
|
|
||
| /** | ||
| * @notice Test CREATE3 with invalid structure (wrong primitive count) | ||
| * @dev Should revert with InvalidCreate3EncodingStructure | ||
| */ | ||
| function testCreate3InvalidStructure() public { | ||
| vm.skip(true); | ||
| // Skip until revert expectations can be validated | ||
| return; | ||
|
|
||
| TypedEncoder.Struct memory encoded = TypedEncoder.Struct({ | ||
| typeHash: keccak256("Invalid()"), | ||
| chunks: new TypedEncoder.Chunk[](1), | ||
| encodingType: TypedEncoder.EncodingType.Create3 | ||
| }); | ||
|
|
||
| // Wrong: only 1 primitive instead of 3 | ||
| encoded.chunks[0].primitives = new TypedEncoder.Primitive[](1); | ||
| encoded.chunks[0].primitives[0] = | ||
| TypedEncoder.Primitive({ isDynamic: false, data: abi.encode(address(0x1234)) }); | ||
|
|
||
| vm.expectRevert(TypedEncoder.InvalidCreate3EncodingStructure.selector); | ||
| encoded.encode(); | ||
| } | ||
|
|
||
| /** | ||
| * @notice Test CREATE3 with too many primitives (invalid) | ||
| * @dev Should revert with InvalidCreate3EncodingStructure | ||
| */ | ||
| function testCreate3TooManyPrimitives() public { | ||
| vm.skip(true); | ||
| // Skip until revert expectations can be validated | ||
| return; | ||
|
|
||
| TypedEncoder.Struct memory encoded = TypedEncoder.Struct({ | ||
| typeHash: keccak256("Invalid()"), | ||
| chunks: new TypedEncoder.Chunk[](1), | ||
| encodingType: TypedEncoder.EncodingType.Create3 | ||
| }); | ||
|
|
||
| // Wrong: 4 primitives instead of 3 | ||
| encoded.chunks[0].primitives = new TypedEncoder.Primitive[](4); | ||
| encoded.chunks[0].primitives[0] = | ||
| TypedEncoder.Primitive({ isDynamic: false, data: abi.encode(address(0x1234)) }); | ||
| encoded.chunks[0].primitives[1] = TypedEncoder.Primitive({ isDynamic: false, data: abi.encode(bytes32(0)) }); | ||
| encoded.chunks[0].primitives[2] = | ||
| TypedEncoder.Primitive({ isDynamic: false, data: abi.encode(keccak256("test")) }); | ||
| encoded.chunks[0].primitives[3] = TypedEncoder.Primitive({ isDynamic: false, data: abi.encode(uint256(123)) }); | ||
|
|
||
| vm.expectRevert(TypedEncoder.InvalidCreate3EncodingStructure.selector); | ||
| encoded.encode(); | ||
| } | ||
|
|
||
| /** | ||
| * @notice Test CREATE3 with wrong data length (invalid) | ||
| * @dev Should revert with InvalidCreate3EncodingStructure | ||
| */ | ||
| function testCreate3InvalidDataLength() public { | ||
| vm.skip(true); | ||
| // Skip until revert expectations can be validated | ||
| return; | ||
|
|
||
| TypedEncoder.Struct memory encoded = TypedEncoder.Struct({ | ||
| typeHash: keccak256("Invalid()"), | ||
| chunks: new TypedEncoder.Chunk[](1), | ||
| encodingType: TypedEncoder.EncodingType.Create3 | ||
| }); | ||
|
|
||
| encoded.chunks[0].primitives = new TypedEncoder.Primitive[](3); | ||
| encoded.chunks[0].primitives[0] = | ||
| TypedEncoder.Primitive({ isDynamic: false, data: abi.encode(address(0x1234)) }); | ||
| encoded.chunks[0].primitives[1] = TypedEncoder.Primitive({ isDynamic: false, data: hex"1234" }); // Wrong: not | ||
| // 32 bytes | ||
| encoded.chunks[0].primitives[2] = | ||
| TypedEncoder.Primitive({ isDynamic: false, data: abi.encode(keccak256("test")) }); | ||
|
|
||
| vm.expectRevert(TypedEncoder.InvalidCreate3EncodingStructure.selector); | ||
| encoded.encode(); | ||
| } |
Contributor
There was a problem hiding this comment.
Why are these tests skipped?
Comment on lines
+31
to
+547
| function testArrayEncodingWithPrimitives() public { | ||
| vm.skip(true); | ||
| // Skip until revert expectations can be validated | ||
| return; | ||
|
|
||
| // Create Array-encoded struct with primitive field (violates structs-only rule) | ||
| TypedEncoder.Struct memory invalidArray = TypedEncoder.Struct({ | ||
| typeHash: keccak256("InvalidArray(uint256 value)"), | ||
| chunks: new TypedEncoder.Chunk[](1), | ||
| encodingType: TypedEncoder.EncodingType.Array | ||
| }); | ||
|
|
||
| // Add primitive to chunk (should fail - Array encoding requires only structs) | ||
| invalidArray.chunks[0].primitives = new TypedEncoder.Primitive[](1); | ||
| invalidArray.chunks[0].primitives[0] = | ||
| TypedEncoder.Primitive({ isDynamic: false, data: abi.encode(uint256(100)) }); | ||
|
|
||
| // Expect revert with UnsupportedArrayType | ||
| vm.expectRevert(TypedEncoder.UnsupportedArrayType.selector); | ||
| invalidArray.encode(); | ||
| } | ||
|
|
||
| /** | ||
| * @notice Tests that Array encoding reverts when chunks contain array fields | ||
| * @dev Error: UnsupportedArrayType | ||
| * Why: Array encoding type requires chunks to contain only struct fields. | ||
| * Nested arrays are not supported in the chunk because the Array encoding | ||
| * is specifically designed for polymorphic struct arrays where each element | ||
| * is a complete struct with its own EIP-712 type hash. | ||
| * TODO: Implement test | ||
| */ | ||
| function testArrayEncodingWithArrays() public { | ||
| vm.skip(true); | ||
| // Skip until revert expectations can be validated | ||
| return; | ||
|
|
||
| // Create Array-encoded struct with array field (violates structs-only rule) | ||
| TypedEncoder.Struct memory invalidArray = TypedEncoder.Struct({ | ||
| typeHash: keccak256("InvalidArray(uint256[] values)"), | ||
| chunks: new TypedEncoder.Chunk[](1), | ||
| encodingType: TypedEncoder.EncodingType.Array | ||
| }); | ||
|
|
||
| // Add array to chunk (should fail - Array encoding requires only structs) | ||
| invalidArray.chunks[0].arrays = new TypedEncoder.Array[](1); | ||
| invalidArray.chunks[0].arrays[0] = TypedEncoder.Array({ isDynamic: true, data: new TypedEncoder.Chunk[](2) }); | ||
| // Populate array elements | ||
| invalidArray.chunks[0].arrays[0].data[0].primitives = new TypedEncoder.Primitive[](1); | ||
| invalidArray.chunks[0].arrays[0].data[0].primitives[0] = | ||
| TypedEncoder.Primitive({ isDynamic: false, data: abi.encode(uint256(1)) }); | ||
| invalidArray.chunks[0].arrays[0].data[1].primitives = new TypedEncoder.Primitive[](1); | ||
| invalidArray.chunks[0].arrays[0].data[1].primitives[0] = | ||
| TypedEncoder.Primitive({ isDynamic: false, data: abi.encode(uint256(2)) }); | ||
|
|
||
| // Expect revert with UnsupportedArrayType | ||
| vm.expectRevert(TypedEncoder.UnsupportedArrayType.selector); | ||
| invalidArray.encode(); | ||
| } | ||
|
|
||
| /** | ||
| * @notice Tests that Array encoding reverts when using multiple chunks | ||
| * @dev Error: UnsupportedArrayType | ||
| * Why: Array encoding requires exactly 1 chunk. Multiple chunks would break the array | ||
| * structure since chunks are for organizing field order within a struct, not for | ||
| * defining array elements. Array elements should be defined as structs within the | ||
| * single chunk. This validation ensures proper array structure. | ||
| */ | ||
| function testArrayEncodingWithMultipleChunks() public { | ||
| vm.skip(true); | ||
| // Skip until revert expectations can be validated | ||
| return; | ||
|
|
||
| // Create Array-encoded struct with 2 chunks (violates exactly-1-chunk rule) | ||
| TypedEncoder.Struct memory invalidArray = TypedEncoder.Struct({ | ||
| typeHash: keccak256("InvalidArray(SimpleStruct s1,SimpleStruct s2)"), | ||
| chunks: new TypedEncoder.Chunk[](2), | ||
| encodingType: TypedEncoder.EncodingType.Array | ||
| }); | ||
|
|
||
| // Add struct to first chunk | ||
| invalidArray.chunks[0].structs = new TypedEncoder.Struct[](1); | ||
| invalidArray.chunks[0].structs[0] = TypedEncoder.Struct({ | ||
| typeHash: keccak256("SimpleStruct(uint256 value)"), | ||
| chunks: new TypedEncoder.Chunk[](1), | ||
| encodingType: TypedEncoder.EncodingType.Struct | ||
| }); | ||
| invalidArray.chunks[0].structs[0].chunks[0].primitives = new TypedEncoder.Primitive[](1); | ||
| invalidArray.chunks[0].structs[0].chunks[0].primitives[0] = | ||
| TypedEncoder.Primitive({ isDynamic: false, data: abi.encode(uint256(1)) }); | ||
|
|
||
| // Add struct to second chunk (invalid - Array encoding requires exactly 1 chunk) | ||
| invalidArray.chunks[1].structs = new TypedEncoder.Struct[](1); | ||
| invalidArray.chunks[1].structs[0] = TypedEncoder.Struct({ | ||
| typeHash: keccak256("SimpleStruct(uint256 value)"), | ||
| chunks: new TypedEncoder.Chunk[](1), | ||
| encodingType: TypedEncoder.EncodingType.Struct | ||
| }); | ||
| invalidArray.chunks[1].structs[0].chunks[0].primitives = new TypedEncoder.Primitive[](1); | ||
| invalidArray.chunks[1].structs[0].chunks[0].primitives[0] = | ||
| TypedEncoder.Primitive({ isDynamic: false, data: abi.encode(uint256(2)) }); | ||
|
|
||
| // Expect revert with UnsupportedArrayType (must have exactly 1 chunk) | ||
| vm.expectRevert(TypedEncoder.UnsupportedArrayType.selector); | ||
| invalidArray.encode(); | ||
| } | ||
|
|
||
| /** | ||
| * @notice Tests that Array encoding reverts when chunk has both structs and primitives/arrays | ||
| * @dev Error: UnsupportedArrayType | ||
| * Why: The single chunk in Array encoding must contain ONLY struct fields. | ||
| * Any primitive or array fields in the chunk violate this constraint. | ||
| * This ensures the output is a clean struct array, not a mixed-type array. | ||
| * TODO: Implement test | ||
| */ | ||
| function testArrayEncodingWithMixedFields() public { | ||
| vm.skip(true); | ||
| // Skip until revert expectations can be validated | ||
| return; | ||
|
|
||
| // Create Array-encoded struct with mixed fields (violates structs-only rule) | ||
| TypedEncoder.Struct memory invalidArray = TypedEncoder.Struct({ | ||
| typeHash: keccak256("InvalidArray(uint256 value,SimpleStruct s)"), | ||
| chunks: new TypedEncoder.Chunk[](1), | ||
| encodingType: TypedEncoder.EncodingType.Array | ||
| }); | ||
|
|
||
| // Add primitive to chunk (invalid - Array encoding requires only structs) | ||
| invalidArray.chunks[0].primitives = new TypedEncoder.Primitive[](1); | ||
| invalidArray.chunks[0].primitives[0] = | ||
| TypedEncoder.Primitive({ isDynamic: false, data: abi.encode(uint256(100)) }); | ||
|
|
||
| // Add struct to chunk (invalid when combined with primitive) | ||
| invalidArray.chunks[0].structs = new TypedEncoder.Struct[](1); | ||
| invalidArray.chunks[0].structs[0] = TypedEncoder.Struct({ | ||
| typeHash: keccak256("SimpleStruct(uint256 value)"), | ||
| chunks: new TypedEncoder.Chunk[](1), | ||
| encodingType: TypedEncoder.EncodingType.Struct | ||
| }); | ||
| invalidArray.chunks[0].structs[0].chunks[0].primitives = new TypedEncoder.Primitive[](1); | ||
| invalidArray.chunks[0].structs[0].chunks[0].primitives[0] = | ||
| TypedEncoder.Primitive({ isDynamic: false, data: abi.encode(uint256(200)) }); | ||
|
|
||
| // Expect revert with UnsupportedArrayType (must have only structs, no primitives) | ||
| vm.expectRevert(TypedEncoder.UnsupportedArrayType.selector); | ||
| invalidArray.encode(); | ||
| } | ||
|
|
||
| /** | ||
| * @notice Tests that CallWithSelector reverts when selector is not exactly 4 bytes | ||
| * @dev Error: InvalidCallEncodingStructure | ||
| * Why: Function selectors in Solidity are always bytes4 (4 bytes). Using any other | ||
| * size (e.g., bytes8, bytes32, or bytes2) would produce invalid calldata that | ||
| * cannot be interpreted by the target contract. This validation ensures the | ||
| * encoded calldata has the correct 4-byte selector prefix. | ||
| * TODO: Implement test | ||
| */ | ||
| function testCallWithSelectorInvalidSelector() public { | ||
| vm.skip(true); | ||
| // Skip until revert expectations can be validated | ||
| return; | ||
|
|
||
| // Create params struct | ||
| TypedEncoder.Struct memory paramsStruct = TypedEncoder.Struct({ | ||
| typeHash: keccak256("TransferParams(address to,uint256 amount)"), | ||
| chunks: new TypedEncoder.Chunk[](1), | ||
| encodingType: TypedEncoder.EncodingType.Struct | ||
| }); | ||
| paramsStruct.chunks[0].primitives = new TypedEncoder.Primitive[](2); | ||
| paramsStruct.chunks[0].primitives[0] = | ||
| TypedEncoder.Primitive({ isDynamic: false, data: abi.encode(address(0x1234)) }); | ||
| paramsStruct.chunks[0].primitives[1] = | ||
| TypedEncoder.Primitive({ isDynamic: false, data: abi.encode(uint256(1000)) }); | ||
|
|
||
| // Create CallWithSelector with invalid 5-byte selector (should be 4 bytes) | ||
| TypedEncoder.Struct memory invalidCall = TypedEncoder.Struct({ | ||
| typeHash: keccak256("InvalidCall(bytes5 selector,TransferParams params)"), | ||
| chunks: new TypedEncoder.Chunk[](1), | ||
| encodingType: TypedEncoder.EncodingType.CallWithSelector | ||
| }); | ||
| invalidCall.chunks[0].primitives = new TypedEncoder.Primitive[](1); | ||
| // Use 5 bytes instead of 4 (invalid) | ||
| invalidCall.chunks[0].primitives[0] = | ||
| TypedEncoder.Primitive({ isDynamic: false, data: abi.encodePacked(bytes5(0x1234567890)) }); | ||
| invalidCall.chunks[0].structs = new TypedEncoder.Struct[](1); | ||
| invalidCall.chunks[0].structs[0] = paramsStruct; | ||
|
|
||
| // Expect revert with InvalidCallEncodingStructure | ||
| vm.expectRevert(TypedEncoder.InvalidCallEncodingStructure.selector); | ||
| invalidCall.encode(); | ||
| } | ||
|
|
||
| /** | ||
| * @notice Tests that CallWithSelector reverts when selector is marked as dynamic | ||
| * @dev Error: InvalidCallEncodingStructure | ||
| * Why: Function selectors are always static (bytes4). A dynamic selector would | ||
| * indicate incorrect construction of the Call structure. The selector primitive | ||
| * must have isDynamic=false because bytes4 is a fixed-size type, not a dynamic | ||
| * type like bytes or string. | ||
| * TODO: Implement test | ||
| */ | ||
| function testCallWithSelectorDynamicSelector() public { | ||
| vm.skip(true); | ||
| // Skip until revert expectations can be validated | ||
| return; | ||
|
|
||
| // Create params struct | ||
| TypedEncoder.Struct memory paramsStruct = TypedEncoder.Struct({ | ||
| typeHash: keccak256("TransferParams(address to,uint256 amount)"), | ||
| chunks: new TypedEncoder.Chunk[](1), | ||
| encodingType: TypedEncoder.EncodingType.Struct | ||
| }); | ||
| paramsStruct.chunks[0].primitives = new TypedEncoder.Primitive[](2); | ||
| paramsStruct.chunks[0].primitives[0] = | ||
| TypedEncoder.Primitive({ isDynamic: false, data: abi.encode(address(0x1234)) }); | ||
| paramsStruct.chunks[0].primitives[1] = | ||
| TypedEncoder.Primitive({ isDynamic: false, data: abi.encode(uint256(1000)) }); | ||
|
|
||
| // Create CallWithSelector with dynamic selector (should be static) | ||
| TypedEncoder.Struct memory invalidCall = TypedEncoder.Struct({ | ||
| typeHash: keccak256("InvalidCall(bytes selector,TransferParams params)"), | ||
| chunks: new TypedEncoder.Chunk[](1), | ||
| encodingType: TypedEncoder.EncodingType.CallWithSelector | ||
| }); | ||
| invalidCall.chunks[0].primitives = new TypedEncoder.Primitive[](1); | ||
| // Mark selector as dynamic (invalid - must be static) | ||
| invalidCall.chunks[0].primitives[0] = | ||
| TypedEncoder.Primitive({ isDynamic: true, data: abi.encodePacked(bytes4(0x12345678)) }); | ||
| invalidCall.chunks[0].structs = new TypedEncoder.Struct[](1); | ||
| invalidCall.chunks[0].structs[0] = paramsStruct; | ||
|
|
||
| // Expect revert with InvalidCallEncodingStructure | ||
| vm.expectRevert(TypedEncoder.InvalidCallEncodingStructure.selector); | ||
| invalidCall.encode(); | ||
| } | ||
|
|
||
| /** | ||
| * @notice Tests that CallWithSelector reverts when using multiple chunks | ||
| * @dev Error: InvalidCallEncodingStructure | ||
| * Why: CallWithSelector requires exactly 1 chunk containing the selector and params. | ||
| * Multiple chunks would break the expected structure and make it impossible to | ||
| * extract the selector and parameters in the correct order. The validation | ||
| * ensures the call structure is properly formed with all required components | ||
| * in a single chunk. | ||
| * TODO: Implement test | ||
| */ | ||
| function testCallWithSelectorMultipleChunks() public { | ||
| vm.skip(true); | ||
| // Skip until revert expectations can be validated | ||
| return; | ||
|
|
||
| // Create params struct | ||
| TypedEncoder.Struct memory paramsStruct = TypedEncoder.Struct({ | ||
| typeHash: keccak256("TransferParams(address to,uint256 amount)"), | ||
| chunks: new TypedEncoder.Chunk[](1), | ||
| encodingType: TypedEncoder.EncodingType.Struct | ||
| }); | ||
| paramsStruct.chunks[0].primitives = new TypedEncoder.Primitive[](2); | ||
| paramsStruct.chunks[0].primitives[0] = | ||
| TypedEncoder.Primitive({ isDynamic: false, data: abi.encode(address(0x1234)) }); | ||
| paramsStruct.chunks[0].primitives[1] = | ||
| TypedEncoder.Primitive({ isDynamic: false, data: abi.encode(uint256(1000)) }); | ||
|
|
||
| // Create CallWithSelector with 2 chunks (violates exactly-1-chunk rule) | ||
| TypedEncoder.Struct memory invalidCall = TypedEncoder.Struct({ | ||
| typeHash: keccak256("InvalidCall(bytes4 selector,TransferParams params)"), | ||
| chunks: new TypedEncoder.Chunk[](2), | ||
| encodingType: TypedEncoder.EncodingType.CallWithSelector | ||
| }); | ||
|
|
||
| // Put selector in first chunk | ||
| invalidCall.chunks[0].primitives = new TypedEncoder.Primitive[](1); | ||
| invalidCall.chunks[0].primitives[0] = | ||
| TypedEncoder.Primitive({ isDynamic: false, data: abi.encodePacked(bytes4(0x12345678)) }); | ||
|
|
||
| // Put params in second chunk (invalid - must be all in one chunk) | ||
| invalidCall.chunks[1].structs = new TypedEncoder.Struct[](1); | ||
| invalidCall.chunks[1].structs[0] = paramsStruct; | ||
|
|
||
| // Expect revert with InvalidCallEncodingStructure (must have exactly 1 chunk) | ||
| vm.expectRevert(TypedEncoder.InvalidCallEncodingStructure.selector); | ||
| invalidCall.encode(); | ||
| } | ||
|
|
||
| /** | ||
| * @notice Tests that CallWithSelector reverts when chunk doesn't have exactly 1 primitive and 1 struct | ||
| * @dev Error: InvalidCallEncodingStructure | ||
| * Why: CallWithSelector must have exactly 1 primitive (the bytes4 selector) and | ||
| * exactly 1 struct (the function parameters). Having 2 primitives, 0 structs, | ||
| * 2 structs, or any array fields violates the expected structure. This validation | ||
| * ensures the encoded output matches abi.encodeWithSelector(selector, ...params). | ||
| * TODO: Implement test | ||
| */ | ||
| function testCallWithSelectorWrongFieldCount() public { | ||
| vm.skip(true); | ||
| // Skip until revert expectations can be validated | ||
| return; | ||
|
|
||
| // Test Case A: 2 primitives + 1 struct (should be 1 + 1) | ||
| TypedEncoder.Struct memory paramsStruct = TypedEncoder.Struct({ | ||
| typeHash: keccak256("Params(uint256 value)"), | ||
| chunks: new TypedEncoder.Chunk[](1), | ||
| encodingType: TypedEncoder.EncodingType.Struct | ||
| }); | ||
| paramsStruct.chunks[0].primitives = new TypedEncoder.Primitive[](1); | ||
| paramsStruct.chunks[0].primitives[0] = | ||
| TypedEncoder.Primitive({ isDynamic: false, data: abi.encode(uint256(100)) }); | ||
|
|
||
| TypedEncoder.Struct memory invalidCallA = TypedEncoder.Struct({ | ||
| typeHash: keccak256("InvalidCall(bytes4 selector,uint256 extra,Params params)"), | ||
| chunks: new TypedEncoder.Chunk[](1), | ||
| encodingType: TypedEncoder.EncodingType.CallWithSelector | ||
| }); | ||
| invalidCallA.chunks[0].primitives = new TypedEncoder.Primitive[](2); | ||
| invalidCallA.chunks[0].primitives[0] = | ||
| TypedEncoder.Primitive({ isDynamic: false, data: abi.encodePacked(bytes4(0x12345678)) }); | ||
| invalidCallA.chunks[0].primitives[1] = | ||
| TypedEncoder.Primitive({ isDynamic: false, data: abi.encode(uint256(999)) }); | ||
| invalidCallA.chunks[0].structs = new TypedEncoder.Struct[](1); | ||
| invalidCallA.chunks[0].structs[0] = paramsStruct; | ||
|
|
||
| vm.expectRevert(TypedEncoder.InvalidCallEncodingStructure.selector); | ||
| invalidCallA.encode(); | ||
|
|
||
| // Test Case B: 1 primitive + 2 structs (should be 1 + 1) | ||
| TypedEncoder.Struct memory paramsStruct2 = TypedEncoder.Struct({ | ||
| typeHash: keccak256("Params2(address addr)"), | ||
| chunks: new TypedEncoder.Chunk[](1), | ||
| encodingType: TypedEncoder.EncodingType.Struct | ||
| }); | ||
| paramsStruct2.chunks[0].primitives = new TypedEncoder.Primitive[](1); | ||
| paramsStruct2.chunks[0].primitives[0] = | ||
| TypedEncoder.Primitive({ isDynamic: false, data: abi.encode(address(0x1234)) }); | ||
|
|
||
| TypedEncoder.Struct memory invalidCallB = TypedEncoder.Struct({ | ||
| typeHash: keccak256("InvalidCall(bytes4 selector,Params params,Params2 params2)"), | ||
| chunks: new TypedEncoder.Chunk[](1), | ||
| encodingType: TypedEncoder.EncodingType.CallWithSelector | ||
| }); | ||
| invalidCallB.chunks[0].primitives = new TypedEncoder.Primitive[](1); | ||
| invalidCallB.chunks[0].primitives[0] = | ||
| TypedEncoder.Primitive({ isDynamic: false, data: abi.encodePacked(bytes4(0x12345678)) }); | ||
| invalidCallB.chunks[0].structs = new TypedEncoder.Struct[](2); | ||
| invalidCallB.chunks[0].structs[0] = paramsStruct; | ||
| invalidCallB.chunks[0].structs[1] = paramsStruct2; | ||
|
|
||
| vm.expectRevert(TypedEncoder.InvalidCallEncodingStructure.selector); | ||
| invalidCallB.encode(); | ||
|
|
||
| // Test Case C: 1 primitive + 1 struct + 1 array (arrays not allowed) | ||
| TypedEncoder.Struct memory invalidCallC = TypedEncoder.Struct({ | ||
| typeHash: keccak256("InvalidCall(bytes4 selector,Params params,uint256[] arr)"), | ||
| chunks: new TypedEncoder.Chunk[](1), | ||
| encodingType: TypedEncoder.EncodingType.CallWithSelector | ||
| }); | ||
| invalidCallC.chunks[0].primitives = new TypedEncoder.Primitive[](1); | ||
| invalidCallC.chunks[0].primitives[0] = | ||
| TypedEncoder.Primitive({ isDynamic: false, data: abi.encodePacked(bytes4(0x12345678)) }); | ||
| invalidCallC.chunks[0].structs = new TypedEncoder.Struct[](1); | ||
| invalidCallC.chunks[0].structs[0] = paramsStruct; | ||
| invalidCallC.chunks[0].arrays = new TypedEncoder.Array[](1); | ||
| invalidCallC.chunks[0].arrays[0] = TypedEncoder.Array({ isDynamic: true, data: new TypedEncoder.Chunk[](0) }); | ||
|
|
||
| vm.expectRevert(TypedEncoder.InvalidCallEncodingStructure.selector); | ||
| invalidCallC.encode(); | ||
| } | ||
|
|
||
| /** | ||
| * @notice Tests that CallWithSignature reverts when signature is static instead of dynamic | ||
| * @dev Error: InvalidCallEncodingStructure | ||
| * Why: Function signatures are strings (e.g., "transfer(address,uint256)"), which are | ||
| * dynamic types in Solidity. A static primitive would indicate the signature was | ||
| * incorrectly constructed (e.g., using bytes32 instead of string/bytes). The | ||
| * validation ensures isDynamic=true for the signature primitive to match the | ||
| * expected behavior of abi.encodeWithSignature. | ||
| * TODO: Implement test | ||
| */ | ||
| function testCallWithSignatureStaticSignature() public { | ||
| vm.skip(true); | ||
| // Skip until revert expectations can be validated | ||
| return; | ||
|
|
||
| // Create params struct | ||
| TypedEncoder.Struct memory paramsStruct = TypedEncoder.Struct({ | ||
| typeHash: keccak256("TransferParams(address to,uint256 amount)"), | ||
| chunks: new TypedEncoder.Chunk[](1), | ||
| encodingType: TypedEncoder.EncodingType.Struct | ||
| }); | ||
| paramsStruct.chunks[0].primitives = new TypedEncoder.Primitive[](2); | ||
| paramsStruct.chunks[0].primitives[0] = | ||
| TypedEncoder.Primitive({ isDynamic: false, data: abi.encode(address(0x1234)) }); | ||
| paramsStruct.chunks[0].primitives[1] = | ||
| TypedEncoder.Primitive({ isDynamic: false, data: abi.encode(uint256(1000)) }); | ||
|
|
||
| // Create CallWithSignature with static signature (should be dynamic) | ||
| TypedEncoder.Struct memory invalidCall = TypedEncoder.Struct({ | ||
| typeHash: keccak256("InvalidCall(bytes32 signature,TransferParams params)"), | ||
| chunks: new TypedEncoder.Chunk[](1), | ||
| encodingType: TypedEncoder.EncodingType.CallWithSignature | ||
| }); | ||
| invalidCall.chunks[0].primitives = new TypedEncoder.Primitive[](1); | ||
| // Mark signature as static (invalid - must be dynamic) | ||
| invalidCall.chunks[0].primitives[0] = | ||
| TypedEncoder.Primitive({ isDynamic: false, data: abi.encode(bytes32("transfer(address,uint256)")) }); | ||
| invalidCall.chunks[0].structs = new TypedEncoder.Struct[](1); | ||
| invalidCall.chunks[0].structs[0] = paramsStruct; | ||
|
|
||
| // Expect revert with InvalidCallEncodingStructure | ||
| vm.expectRevert(TypedEncoder.InvalidCallEncodingStructure.selector); | ||
| invalidCall.encode(); | ||
| } | ||
|
|
||
| /** | ||
| * @notice Tests that CallWithSignature reverts with invalid structure (wrong field counts) | ||
| * @dev Error: InvalidCallEncodingStructure | ||
| * Why: CallWithSignature requires exactly 1 primitive (the signature string) and | ||
| * exactly 1 struct (the function parameters). Any deviation from this structure | ||
| * (e.g., 0 primitives, 2 structs, array fields) would produce invalid calldata | ||
| * that doesn't match abi.encodeWithSignature output. This validation ensures | ||
| * the call can be properly encoded with the signature-derived selector. | ||
| * TODO: Implement test | ||
| */ | ||
| function testCallWithSignatureInvalidStructure() public { | ||
| vm.skip(true); | ||
| // Skip until revert expectations can be validated | ||
| return; | ||
|
|
||
| // Test Case A: Multiple chunks (should be exactly 1) | ||
| TypedEncoder.Struct memory paramsStruct = TypedEncoder.Struct({ | ||
| typeHash: keccak256("Params(uint256 value)"), | ||
| chunks: new TypedEncoder.Chunk[](1), | ||
| encodingType: TypedEncoder.EncodingType.Struct | ||
| }); | ||
| paramsStruct.chunks[0].primitives = new TypedEncoder.Primitive[](1); | ||
| paramsStruct.chunks[0].primitives[0] = | ||
| TypedEncoder.Primitive({ isDynamic: false, data: abi.encode(uint256(100)) }); | ||
|
|
||
| TypedEncoder.Struct memory invalidCallA = TypedEncoder.Struct({ | ||
| typeHash: keccak256("InvalidCall(string signature,Params params)"), | ||
| chunks: new TypedEncoder.Chunk[](2), | ||
| encodingType: TypedEncoder.EncodingType.CallWithSignature | ||
| }); | ||
| invalidCallA.chunks[0].primitives = new TypedEncoder.Primitive[](1); | ||
| invalidCallA.chunks[0].primitives[0] = | ||
| TypedEncoder.Primitive({ isDynamic: true, data: abi.encodePacked("transfer(address,uint256)") }); | ||
| invalidCallA.chunks[1].structs = new TypedEncoder.Struct[](1); | ||
| invalidCallA.chunks[1].structs[0] = paramsStruct; | ||
|
|
||
| vm.expectRevert(TypedEncoder.InvalidCallEncodingStructure.selector); | ||
| invalidCallA.encode(); | ||
|
|
||
| // Test Case B: Wrong primitive count - 0 primitives (should be 1) | ||
| TypedEncoder.Struct memory invalidCallB = TypedEncoder.Struct({ | ||
| typeHash: keccak256("InvalidCall(Params params)"), | ||
| chunks: new TypedEncoder.Chunk[](1), | ||
| encodingType: TypedEncoder.EncodingType.CallWithSignature | ||
| }); | ||
| invalidCallB.chunks[0].structs = new TypedEncoder.Struct[](1); | ||
| invalidCallB.chunks[0].structs[0] = paramsStruct; | ||
|
|
||
| vm.expectRevert(TypedEncoder.InvalidCallEncodingStructure.selector); | ||
| invalidCallB.encode(); | ||
|
|
||
| // Test Case C: Wrong primitive count - 2 primitives (should be 1) | ||
| TypedEncoder.Struct memory invalidCallC = TypedEncoder.Struct({ | ||
| typeHash: keccak256("InvalidCall(string signature,string extra,Params params)"), | ||
| chunks: new TypedEncoder.Chunk[](1), | ||
| encodingType: TypedEncoder.EncodingType.CallWithSignature | ||
| }); | ||
| invalidCallC.chunks[0].primitives = new TypedEncoder.Primitive[](2); | ||
| invalidCallC.chunks[0].primitives[0] = | ||
| TypedEncoder.Primitive({ isDynamic: true, data: abi.encodePacked("transfer(address,uint256)") }); | ||
| invalidCallC.chunks[0].primitives[1] = | ||
| TypedEncoder.Primitive({ isDynamic: true, data: abi.encodePacked("extra") }); | ||
| invalidCallC.chunks[0].structs = new TypedEncoder.Struct[](1); | ||
| invalidCallC.chunks[0].structs[0] = paramsStruct; | ||
|
|
||
| vm.expectRevert(TypedEncoder.InvalidCallEncodingStructure.selector); | ||
| invalidCallC.encode(); | ||
|
|
||
| // Test Case D: Wrong struct count - 0 structs (should be 1) | ||
| TypedEncoder.Struct memory invalidCallD = TypedEncoder.Struct({ | ||
| typeHash: keccak256("InvalidCall(string signature)"), | ||
| chunks: new TypedEncoder.Chunk[](1), | ||
| encodingType: TypedEncoder.EncodingType.CallWithSignature | ||
| }); | ||
| invalidCallD.chunks[0].primitives = new TypedEncoder.Primitive[](1); | ||
| invalidCallD.chunks[0].primitives[0] = | ||
| TypedEncoder.Primitive({ isDynamic: true, data: abi.encodePacked("transfer(address,uint256)") }); | ||
|
|
||
| vm.expectRevert(TypedEncoder.InvalidCallEncodingStructure.selector); | ||
| invalidCallD.encode(); | ||
|
|
||
| // Test Case E: Wrong struct count - 2 structs (should be 1) | ||
| TypedEncoder.Struct memory paramsStruct2 = TypedEncoder.Struct({ | ||
| typeHash: keccak256("Params2(address addr)"), | ||
| chunks: new TypedEncoder.Chunk[](1), | ||
| encodingType: TypedEncoder.EncodingType.Struct | ||
| }); | ||
| paramsStruct2.chunks[0].primitives = new TypedEncoder.Primitive[](1); | ||
| paramsStruct2.chunks[0].primitives[0] = | ||
| TypedEncoder.Primitive({ isDynamic: false, data: abi.encode(address(0x5678)) }); | ||
|
|
||
| TypedEncoder.Struct memory invalidCallE = TypedEncoder.Struct({ | ||
| typeHash: keccak256("InvalidCall(string signature,Params params,Params2 params2)"), | ||
| chunks: new TypedEncoder.Chunk[](1), | ||
| encodingType: TypedEncoder.EncodingType.CallWithSignature | ||
| }); | ||
| invalidCallE.chunks[0].primitives = new TypedEncoder.Primitive[](1); | ||
| invalidCallE.chunks[0].primitives[0] = | ||
| TypedEncoder.Primitive({ isDynamic: true, data: abi.encodePacked("transfer(address,uint256)") }); | ||
| invalidCallE.chunks[0].structs = new TypedEncoder.Struct[](2); | ||
| invalidCallE.chunks[0].structs[0] = paramsStruct; | ||
| invalidCallE.chunks[0].structs[1] = paramsStruct2; | ||
|
|
||
| vm.expectRevert(TypedEncoder.InvalidCallEncodingStructure.selector); | ||
| invalidCallE.encode(); | ||
| } |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
No description provided.