캐시할 수 있는 모든 것

1// SPDX-License-Identifier: UNLICENSED
2pragma solidity ^0.8.13;
3
4
5contract Cache {
6
7    bytes1 public constant INTO_CACHE = 0xFF;
8    bytes1 public constant DONT_CACHE = 0xFE;
복사

1
2    mapping(uint => uint) public val2key;
복사

1    // 위치 n에는 키 n+1의 값이 들어갑니다.
2    // 0은 "캐시에 없음"을 나타내기 위해 남겨둬야 합니다.
3    uint[] public key2val;
복사

1    function cacheRead(uint _key) public view returns (uint) {
2        require(_key <= key2val.length, "초기화되지 않은 캐시 항목 읽기");
3        return key2val[_key-1];
4    }  // cacheRead
복사

1    // 캐시에 값이 아직 없는 경우 값을 씁니다
2    // 테스트가 작동하도록 공개(public)로 설정
3    function cacheWrite(uint _value) public returns (uint) {
4        // 값이 이미 캐시에 있는 경우 현재 키를 반환합니다
5        if (val2key[_value] != 0) {
6            return val2key[_value];
7        }
복사

1        // 0xFE는 특수한 경우이므로 캐시가 가질 수 있는
2        // 가장 큰 키는 0x0D 뒤에 15개의 0xFF가 오는 것입니다. 캐시 길이가 이미
3        // 그만큼 크면 실패합니다.
4        //                              1 2 3 4 5 6 7 8 9 A B C D E F
5        require(key2val.length+1 < 0x0DFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF,
6            "캐시 오버플로우");
복사

1        // 다음 키를 사용하여 값을 씁니다
2        val2key[_value] = key2val.length+1;
복사

1        key2val.push(_value);
복사

1        return key2val.length;
2    }  // cacheWrite
복사

1    function _calldataVal(uint startByte, uint length)
2        private pure returns (uint)
복사

1    {
2        uint _retVal;
3
4        require(length < 0x21,
5            "_calldataVal 길이 제한은 32바이트입니다");
6        require(length + startByte <= msg.data.length,
7            "_calldataVal이 calldatasize를 초과하여 읽으려 합니다");
복사

1        assembly {
2            _retVal := calldataload(startByte)
3        }
복사

1        _retVal = _retVal >> (256-length*8);
복사

1        return _retVal;
2    } // _calldataVal
3
4
5    // _fromByte에서 시작하여 calldata에서 단일 매개변수를 읽습니다.
6    function _readParam(uint _fromByte) internal
7        returns (uint _nextByte, uint _parameterValue)
8    {
복사

1        // 첫 번째 바이트는 나머지를 해석하는 방법을 알려줍니다.
2        uint8 _firstByte;
3
4        _firstByte = uint8(_calldataVal(_fromByte, 1));
복사

1
2        // 값을 읽지만 캐시에 쓰지 않습니다.
3        if (_firstByte == uint8(DONT_CACHE))
4            return(_fromByte+33, _calldataVal(_fromByte+1, 32));
5
6        // 값을 읽고 캐시에 씁니다.
7        if (_firstByte == uint8(INTO_CACHE)) {
8            uint _param = _calldataVal(_fromByte+1, 32);
9            cacheWrite(_param);
10            return(_fromByte+33, _param);
11        }
12
13        // 여기까지 오면 캐시에서 읽어야 한다는 의미입니다.
14
15        // 읽을 추가 바이트 수
16        uint8 _extraBytes = _firstByte / 16;
모두 보기
복사

1        uint _key = (uint256(_firstByte & 0x0F) << (8*_extraBytes)) +
2            _calldataVal(_fromByte+1, _extraBytes);
3
4        return (_fromByte+_extraBytes+1, cacheRead(_key));
5
6    }  // _readParam
7
8
9    // n개의 매개변수 읽기(함수는 예상하는 매개변수 수를 알고 있습니다)
10    function _readParams(uint _paramNum) internal returns (uint[] memory) {
모두 보기
복사

1        // 읽은 매개변수들
2        uint[] memory params = new uint[](_paramNum);
3
4        // 매개변수는 4번째 바이트에서 시작하며, 그 이전은 함수 서명입니다.
5        uint _atByte = 4;
6
7        for(uint i=0; i<_paramNum; i++) {
8            (_atByte, params[i]) = _readParam(_atByte);
9        }
모두 보기
복사

1
2        return(params);
3    }   // readParams
4
5    // _readParams 테스트를 위해 4개의 매개변수 읽기 테스트
6    function fourParam() public
7        returns (uint256,uint256,uint256,uint256)
8    {
9        uint[] memory params;
10        params = _readParams(4);
11        return (params[0], params[1], params[2], params[3]);
12    }    // fourParam
모두 보기
복사

1    // 값을 가져와 인코딩할 바이트를 반환합니다(가능한 경우 캐시 사용).
2    function encodeVal(uint _val) public view returns(bytes memory) {
복사

1        uint _key = val2key[_val];
2
3        // 값이 아직 캐시에 없으므로 추가합니다.
4        if (_key == 0)
5            return bytes.concat(INTO_CACHE, bytes32(_val));
복사

1        // 키가 0x10보다 작으면 단일 바이트로 반환합니다.
2        if (_key < 0x10)
3            return bytes.concat(bytes1(uint8(_key)));
복사

1        // 0x1vvv로 인코딩된 2바이트 값
2        if (_key < 0x1000)
3            return bytes.concat(bytes2(uint16(_key) | 0x1000));
복사

1        // 다음 줄을 루프로 수행하는 영리한 방법이 있을 수 있지만,
2        // view 함수이므로 프로그래머 시간과
3        // 단순성을 위해 최적화하고 있습니다.
4
5        if (_key < 16*256**2)
6            return bytes.concat(bytes3(uint24(_key) | (0x2 * 16 * 256**2)));
7        if (_key < 16*256**3)
8            return bytes.concat(bytes4(uint32(_key) | (0x3 * 16 * 256**3)));
9             .
10             .
11             .
12        if (_key < 16*256**14)
13            return bytes.concat(bytes15(uint120(_key) | (0xE * 16 * 256**14)));
14        if (_key < 16*256**15)
15            return bytes.concat(bytes16(uint128(_key) | (0xF * 16 * 256**15)));
모두 보기
복사

1        // 여기에 도달하면 뭔가 잘못된 것입니다.
2        revert("encodeVal 오류, 발생해서는 안 됨");
복사

1    } // encodeVal
2
3}  // Cache
복사

1// SPDX-License-Identifier: UNLICENSED
2pragma solidity ^0.8.13;
3
4import "forge-std/Test.sol";
5
6
7// console을 사용하려면 `forge test -vv`를 실행해야 합니다.
8import "forge-std/console.sol";
복사

1import "src/Cache.sol";
복사

1contract CacheTest is Test {
2    Cache cache;
3
4    function setUp() public {
5        cache = new Cache();
6    }
복사

1    function testCaching() public {
복사

1        for(uint i=1; i<5000; i++) {
2            cache.cacheWrite(i*i);
3        }
4
5        for(uint i=1; i<5000; i++) {
6            assertEq(cache.cacheRead(i), i*i);
복사

1        }
2    }    // testCaching
3
4
5    // 동일한 값을 여러 번 캐시하고 키가 동일하게
6    // 유지되는지 확인합니다.
7    function testRepeatCaching() public {
8        for(uint i=1; i<100; i++) {
9            uint _key1 = cache.cacheWrite(i);
10            uint _key2 = cache.cacheWrite(i);
11            assertEq(_key1, _key2);
12        }
모두 보기
복사

1        for(uint i=1; i<100; i+=3) {
2            uint _key = cache.cacheWrite(i);
3            assertEq(_key, i);
4        }
5    }    // testRepeatCaching
복사

1    // 메모리 버퍼에서 uint를 읽습니다(보낸 매개변수를
2    // 다시 받는지 확인하기 위해).
3    function toUint256(bytes memory _bytes, uint256 _start) internal pure
4        returns (uint256)
복사

1    {
2        require(_bytes.length >= _start + 32, "toUint256_outOfBounds");
3        uint256 tempUint;
4
5        assembly {
6            tempUint := mload(add(add(_bytes, 0x20), _start))
7        }
복사

1
2        return tempUint;
3    }     // toUint256
4
5    // fourParams()의 함수 서명, 제공처:
6    // https://www.4byte.directory/signatures/?bytes4_signature=0x3edc1e6d
7    bytes4 constant FOUR_PARAMS = 0x3edc1e6d;
8
9    // 올바른 값을 반환하는지 확인하기 위한 일부 상수 값
10    uint256 constant VAL_A = 0xDEAD60A7;
11    uint256 constant VAL_B =     0xBEEF;
12    uint256 constant VAL_C =     0x600D;
13    uint256 constant VAL_D = 0x600D60A7;
모두 보기
복사

1    function testReadParam() public {
복사

1        address _cacheAddr = address(cache);
2        bool _success;
3        bytes memory _callInput;
4        bytes memory _callOutput;
복사

1        // 첫 번째 호출, 캐시는 비어 있습니다.
2        _callInput = bytes.concat(
3            FOUR_PARAMS,
복사

1            // 첫 번째 값, 캐시에 추가합니다.
2            cache.INTO_CACHE(),
3            bytes32(VAL_A),
복사

1             .
2             .
3             .
4        );
5        (_success, _callOutput) = _cacheAddr.call(_callInput);
복사

1        assertEq(_success, true);
복사

1        assertEq(cache.cacheRead(1), VAL_A);
2        assertEq(cache.cacheRead(2), VAL_C);
복사

1        assertEq(toUint256(_callOutput,0), VAL_A);
2        assertEq(toUint256(_callOutput,32), VAL_B);
3        assertEq(toUint256(_callOutput,64), VAL_C);
4        assertEq(toUint256(_callOutput,96), VAL_C);

1        // 두 번째 호출, 캐시를 사용할 수 있습니다.
2        _callInput = bytes.concat(
3            FOUR_PARAMS,
4
5            // 캐시의 첫 번째 값
6            bytes1(0x01),
복사

1            // 두 번째 값, 캐시에 추가하지 마십시오.
2            cache.DONT_CACHE(),
3            bytes32(VAL_B),
4
5            // 세 번째 및 네 번째 값, 동일한 값
6            bytes1(0x02),
7            bytes1(0x02)
8        );
9        .
10        .
11        .
12    }   // testReadParam
모두 보기
복사

1    function testEncodeVal() public {
복사

1        .
2        .
3        .
4        _callInput = bytes.concat(
5            FOUR_PARAMS,
6            cache.encodeVal(VAL_A),
7            cache.encodeVal(VAL_B),
8            cache.encodeVal(VAL_C),
9            cache.encodeVal(VAL_D)
10        );
11        .
12        .
13        .
14        assertEq(_callInput.length, 4+1*4);
15    }   // testEncodeVal
모두 보기
복사

1    // 키가 단일 바이트 이상일 때 encodeVal 테스트
2    // 캐시를 4바이트로 채우는 데 시간이
3    // 너무 오래 걸리므로 최대 3바이트.
4    function testEncodeValBig() public {
5        // 캐시에 여러 값을 넣습니다.
6        // 간단하게 하기 위해 키 n을 값 n에 사용합니다.
7        for(uint i=1; i<0x1FFF; i++) {
8            cache.cacheWrite(i);
9        }
모두 보기
복사

1        .
2        .
3        .
4
5        _callInput = bytes.concat(
6            FOUR_PARAMS,
7            cache.encodeVal(0x000F),   // 1바이트        0x0F
8            cache.encodeVal(0x0010),   // 2바이트     0x1010
9            cache.encodeVal(0x0100),   // 2바이트     0x1100
10            cache.encodeVal(0x1000)    // 3바이트 0x201000
11        );
모두 보기
복사

1        .
2        .
3        .
4        .
5    }    // testEncodeValBig
6
7
8    // 너무 작은 버퍼로 되돌림을 얻는 것을 테스트합니다.
9    function testShortCalldata() public {
모두 보기
복사

1        .
2        .
3        .
4        (_success, _callOutput) = _cacheAddr.call(_callInput);
5        assertEq(_success, false);
6    }   // testShortCalldata
복사

1    // 없는 캐시 키로 호출
2    function testNoCacheKey() public {
3        .
4        .
5        .
6        _callInput = bytes.concat(
7            FOUR_PARAMS,
8
9            // 첫 번째 값, 캐시에 추가합니다.
10            cache.INTO_CACHE(),
11            bytes32(VAL_A),
12
13            // 두 번째 값
14            bytes1(0x0F),
15            bytes2(0x1234),
16            bytes11(0xA10102030405060708090A)
17        );
모두 보기

1        .
2        .
3        .
4    // 너무 긴 버퍼로 모든 것이 잘 작동하는지 테스트합니다.
5    function testLongCalldata() public {
6        address _cacheAddr = address(cache);
7        bool _success;
8        bytes memory _callInput;
9        bytes memory _callOutput;
10
11        // 첫 번째 호출, 캐시는 비어 있습니다.
12        _callInput = bytes.concat(
13            FOUR_PARAMS,
14
15            // 첫 번째 값, 캐시에 추가합니다.
16            cache.INTO_CACHE(), bytes32(VAL_A),
17
18            // 두 번째 값, 캐시에 추가합니다.
19            cache.INTO_CACHE(), bytes32(VAL_B),
20
21            // 세 번째 값, 캐시에 추가합니다.
22            cache.INTO_CACHE(), bytes32(VAL_C),
23
24            // 네 번째 값, 캐시에 추가합니다.
25            cache.INTO_CACHE(), bytes32(VAL_D),
26
27            // 그리고 "행운을 빌며" 또 다른 값을 추가합니다.
28            bytes4(0x31112233)
29        );
모두 보기
복사

1        (_success, _callOutput) = _cacheAddr.call(_callInput);
2        assertEq(_success, true);
3        .
4        .
5        .
6    }   // testLongCalldata
7
8}        // CacheTest
9
모두 보기
복사

1import "./Cache.sol";
2
3contract WORM is Cache {
복사

1    function writeEntryCached() external {
2        uint[] memory params = _readParams(2);
3        writeEntry(params[0], params[1]);
4    }    // writeEntryCached
복사

1    // 더 쉽게 호출할 수 있도록 합니다.
2    // writeEntryCached()의 함수 서명, 제공처:
3    // https://www.4byte.directory/signatures/?bytes4_signature=0xe4e4f2d3
4    bytes4 constant public WRITE_ENTRY_CACHED = 0xe4e4f2d3;
복사

1    function readEntry(uint key) public view
2        returns (uint _value, address _writtenBy, uint _writtenAtBlock)
복사

1    function testWReadWrite() public {
2        worm.writeEntry(0xDEAD, 0x60A7);
3
4        vm.expectRevert(bytes("항목이 이미 작성됨"));
5        worm.writeEntry(0xDEAD, 0xBEEF);
복사

1    function testReadWriteCached() public {
2        uint cacheGoat = worm.cacheWrite(0x60A7);
복사

1        (_success,) = address(worm).call(_callInput);
복사

1        (_success,) = address(worm).call(_callInput);
2        assertEq(_success, false);
복사

1    event EntryWritten(uint indexed key, uint indexed value);
2
3        .
4        .
5        .
6
7        _callInput = bytes.concat(
8            worm.WRITE_ENTRY_CACHED(), worm.encodeVal(a), worm.encodeVal(b));
9        vm.expectEmit(true, true, false, false);
10        emit EntryWritten(a, b);
11        (_success,) = address(worm).call(_callInput);
모두 보기
복사

1.
2.
3.
4const main = async () => {
5    const func = await worm.WRITE_ENTRY_CACHED()
6
7    // 매번 새로운 키가 필요합니다.
8    const key = await worm.encodeVal(Number(new Date()))

1const val = await worm.encodeVal("0x600D")
2
3// 항목 작성
4const calldata = func + key.slice(2) + val.slice(2)

1const tx = await worm.populateTransaction.writeEntryCached()
2tx.data = calldata
3
4sentTx = await wallet.sendTransaction(tx)

1    .
2    .
3    .
4    // 방금 작성한 항목 읽기
5    const realKey = '0x' + key.slice(4)  // FF 플래그 제거
6    const entryRead = await worm.readEntry(realKey)
7    .
8    .
9    .
모두 보기