Solidity Assembly – How to Decode a Nested encodePacked

abiencoderv2assemblydecodingsolidityyul

The structure of the encoding is

    abi.encodePacked(
       abi.encodePacked(
          address,
          uint256,
          uint256,
          address,
          uint256,
          address,
          uint32,
          uint16
       ),
       abi.encodePacked(
          address,
          uint256,
          uint256
       ),
       address,
       uint256
    )

(They only save 2 slots, I'm not sure why they did it this way)

I want to decode the first encode packed (called the 'offer' which is 162 bytes) from the entire thing.

I wrote this code which isn't working, though the bottom assembly block works for a non-nested encodePacked (abi.encode(encodePacked(..),encodePacked(...),...)

        bytes memory data; // = abi.encodePacked(abi.encodePacked(...),abi.encodePacked(...),address,uint256)

        bytes memory offer;

        assembly {
            offer := mload(add(offer,162))
        }
        
        address denomination;
        uint principal;
        uint repaymentWithFee;
        address collection;
        uint nft_id;
        address referrer;
        uint32 duration;
        uint16 adminFee_bps;
        
        assembly { 
            denomination := mload(add(offer,20))
            principal := mload(add(offer,52))
            repaymentWithFee := mload(add(offer,84))
            collection := mload(add(offer,104))
            nft_id := mload(add(offer,136))
            referrer := mload(add(offer,156))
            duration := mload(add(offer,160))
            adminFee_bps := mload(add(offer,162))
        }

Best Answer

I'm not sure what you were trying to do with offer := mload(add(offer,162)). In any case the second assembly block you have is correct, you only need to mload directly from data.

The first arguments of data are indeed denomination, principal, etc., since everything is packed. There's no bytes memory offer argument inside data that we need to decode, you only have that in the case data = abi.encode(encodePacked(..),encodePacked(...),...).

This works:

struct Offer {
    address denomination;
    uint principal;
    uint repaymentWithFee;
    address collection;
    uint nft_id;
    address referrer;
    uint32 duration;
    uint16 adminFee_bps;
}

contract DecodePacked {
    function testDecodePacked() external pure returns(Offer memory) {
        bytes memory data = packExample();

        address denomination;
        uint principal;
        uint repaymentWithFee;
        address collection;
        uint nft_id;
        address referrer;
        uint32 duration;
        uint16 adminFee_bps;

        assembly { 
            denomination := mload(add(data,20))
            principal := mload(add(data,52))
            repaymentWithFee := mload(add(data,84))
            collection := mload(add(data,104))
            nft_id := mload(add(data,136))
            referrer := mload(add(data,156))
            duration := mload(add(data,160))
            adminFee_bps := mload(add(data,162))
        }

        return Offer(
            denomination, principal, repaymentWithFee, collection, nft_id, referrer, duration, adminFee_bps
        );
    }

    // returns an example for nested encodePacked
    function packExample() public pure returns(bytes memory) {
        return abi.encodePacked(
            abi.encodePacked(
                address(0x01),
                uint256(0x02),
                uint256(0x03),
                address(0x04),
                uint256(0x05),
                address(0x06),
                uint32(0x07),
                uint16(0x08)
            ),
            abi.encodePacked(
                address(0x09),
                uint256(0x10),
                uint256(0x11)
            ),
            address(0x12),
            uint256(0x13)
        );
    }
}

Adding data to the existing byte array (use the 2nd version)

This version is flawed, do not use it. I left it only because I believe it can be informative.

function encodeAmount(uint256 amount, bytes memory data) public pure returns(bytes memory) {

        require(data.length == 68, "Expected 68 bytes of data");

        assembly {
            // No need to abi encode amount. It's already a 32 bytes values (uint256).
            // Just write it directly after the existing data
            mstore(add(add(data, 32), 68), amount)

            // Increase the length of the byte array by 32 to account for the added data
            mstore(data, add(mload(data), 32))

            // Set the free memory pointer to data + 32 + data.length to ensure that
            // subsequent allocations do not overwrite what we just added.
            mstore(0x40, add(data, add(mload(data), 32)))
        }
        return data;
    }

Which yields 0xe5b07cdb0000000000000000000000003416cf6c708da44db2624d63ea0aaef7113527c6000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000f4240

e5b07cdb (function selector)
0000000000000000000000003416cf6c708da44db2624d63ea0aaef7113527c6 (address)
0000000000000000000000000000000000000000000000000000000000000001 (32 bytes value)
00000000000000000000000000000000000000000000000000000000000f4240 (added 32 bytes value : 1000000)

EDIT: I figured that this version has a flaw if data is not the result of the last memory allocation. mstore(0x40, add(data, add(mload(data), 32))) may take the free memory pointer back and leave the memory in an inconsistent state.

This example that illustrate the flaw :

contract Test {

    struct Wrapper {
        uint256 value;
    }

    function edgeCase(uint256 amount, bytes memory data) public pure returns (bytes memory, Wrapper memory walue) {

        // Assuming data starts at offset 0 :
        // data : [0 : 32 + 68] = 100 bytes
        // Free memory starts at 100

        // wrapper is 32 bytes long allocated at the free memory pointer (100)
        // Free memory now starts at 132
        Wrapper memory wrapper;

        wrapper.value = 0;

        // This will take the free memory pointer back to :
        // data (0) + 32 (length) + data.length (68) + 32 (amount) = 132
        // leaving wrapper in an inconsistent state as it is
        // it overwritten by the byte array returned by encodeAmount.
        // Both wrapper and the encoded byte array use the same memory space.
        // With more than 32 bytes allocated between data and the call
        // the free memory pointer will be decremented.
        return (encodeAmount(amount, data), wrapper);
    }


    function encodeAmount(uint256 amount, bytes memory data) public pure returns(bytes memory) {

        require(data.length == 68, "Expected 68 bytes of data");

        assembly {
            // No need to abi encode amount. It's already a 32 bytes values (uint256).
            // Just write it directly after the existing data
            mstore(add(add(data, 32), 68), amount)

            // Increase the length of the byte array by 32 to account for the added data
            mstore(data, add(mload(data), 32))

            // Set the free memory pointer to data + 32 + data.length to ensure that
            // subsequent allocations do not overwrite what we just added.
            mstore(0x40, add(data, add(mload(data), 32)))
        }
        return data;
    }
}

It's therefore better to use the following version that creates a new byte array and ensure memory consistency for previously allocated data.

I strongly advise using that version and not the previous one due to the flaw I mentioned before.

function encodeAmount(uint256 amount, bytes memory data) public pure returns(bytes memory encoded) {

    require(data.length == 68, "Expected 68 bytes of data");

        assembly {

            // Take a free memory space for the new array
            encoded := mload(0x40)

            // Set the size of the new array
            mstore(encoded, add(mload(data), 32))

            // Set the content of the new array by blocks of 32 bytes
            for {let i:= 0} lt(i, mload(data)) {i := add(i, 32)} {
                mstore(add(add(encoded, 32), i), mload(add(add(data, 32), i)))
            }

            // No need to abi encode amount. It's already a 32 bytes values (uint256).
            // Just write it directly after the existing data
            mstore(add(add(encoded, 32), 68), amount)

            // Update the free memory pointer
            mstore(0x40, add(encoded, add(mload(encoded), 32)))
        }

    return encoded;
}

Overwriting the last 32 bytes of the byte array

function overwriteAmount(uint256 amount, bytes memory data) public pure returns(bytes memory) {

        require(data.length == 68, "Expected 68 bytes of data");

        assembly {
            // No need to abi encode amount. It's already a 32 bytes values (uint256).
            // Just write it directly over the last 32 bytes of data
            mstore(add(add(data, 32), 36), amount)
        }
        return data;
    }

There is no need to update the length or the free memory pointer in that case since we did not change anything to the memory layout, only the memory content of already allocated memory space.

Which yields 0xe5b07cdb0000000000000000000000003416cf6c708da44db2624d63ea0aaef7113527c600000000000000000000000000000000000000000000000000000000000f4240

e5b07cdb (function selector)
0000000000000000000000003416cf6c708da44db2624d63ea0aaef7113527c6 (address)
00000000000000000000000000000000000000000000000000000000000f4240 (32 bytes value : 1000000)

I hope that answers your question.

Best Answer

Related Solutions

ABI Encoder – abi.decode with Experimental ABIEncoderV2 Reverts with Nested Arrays

Solidity – How to Retrieve Data After mstore in Yul?

Adding data to the existing byte array (use the 2nd version)

Overwriting the last 32 bytes of the byte array

Related Topic