Semua yang dapat Anda cache

1// SPDX-License-Identifier: UNLICENSED // 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;
Salin

1
2    mapping(uint => uint) public val2key;
Salin

1    // Location n has the value for key n+1, because we need to preserve // Lokasi n memiliki nilai untuk kunci n+1, karena kita perlu mempertahankan
2    // zero as "not in the cache". // nol sebagai "tidak ada di dalam cache".
3    uint[] public key2val;
Salin

1    function cacheRead(uint _key) public view returns (uint) {
2        require(_key <= key2val.length, "Reading uninitialize cache entry");
3        return key2val[_key-1];
4    }  // cacheRead // cacheRead
Salin

1    // Write a value to the cache if it's not there already // Tulis nilai ke cache jika belum ada di sana
2    // Only public to enable the test to work // Hanya publik untuk memungkinkan pengujian berfungsi
3    function cacheWrite(uint _value) public returns (uint) {
4        // If the value is already in the cache, return the current key // Jika nilai sudah ada di dalam cache, kembalikan kunci saat ini
5        if (val2key[_value] != 0) {
6            return val2key[_value];
7        }
Salin

1        // Since 0xFE is a special case, the largest key the cache can // Karena 0xFE adalah kasus khusus, kunci terbesar yang dapat
2        // hold is 0x0D followed by 15 0xFF's. If the cache length is already that // disimpan cache adalah 0x0D diikuti oleh 15 0xFF. Jika panjang cache sudah sebesar itu,
3        // large, fail. // gagal.
4        //                              1 2 3 4 5 6 7 8 9 A B C D E F // 1 2 3 4 5 6 7 8 9 A B C D E F
5        require(key2val.length+1 < 0x0DFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF,
6            "cache overflow");
Salin

1        // Write the value using the next key // Tulis nilai menggunakan kunci berikutnya
2        val2key[_value] = key2val.length+1;
Salin

1        key2val.push(_value);
Salin

1        return key2val.length;
2    }  // cacheWrite // cacheWrite
Salin

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

1    {
2        uint _retVal;
3
4        require(length < 0x21,
5            "_calldataVal length limit is 32 bytes");
6        require(length + startByte <= msg.data.length,
7            "_calldataVal trying to read beyond calldatasize");
Salin

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

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

1        return _retVal;
2    } // _calldataVal // _calldataVal
3
4
5    // Read a single parameter from the calldata, starting at _fromByte // Baca satu parameter dari calldata, dimulai dari _fromByte
6    function _readParam(uint _fromByte) internal
7        returns (uint _nextByte, uint _parameterValue)
8    {
Salin

1        // The first byte tells us how to interpret the rest // Byte pertama memberi tahu kita cara menafsirkan sisanya
2        uint8 _firstByte;
3
4        _firstByte = uint8(_calldataVal(_fromByte, 1));
Salin

1
2        // Read the value, but do not write it to the cache // Baca nilai, tetapi jangan tulis ke cache
3        if (_firstByte == uint8(DONT_CACHE))
4            return(_fromByte+33, _calldataVal(_fromByte+1, 32));
5
6        // Read the value, and write it to the cache // Baca nilai, dan tulis ke cache
7        if (_firstByte == uint8(INTO_CACHE)) {
8            uint _param = _calldataVal(_fromByte+1, 32);
9            cacheWrite(_param);
10            return(_fromByte+33, _param);
11        }
12
13        // If we got here it means that we need to read from the cache // Jika kita sampai di sini, itu berarti kita perlu membaca dari cache
14
15        // Number of extra bytes to read // Jumlah byte tambahan untuk dibaca
16        uint8 _extraBytes = _firstByte / 16;
Tampilkan semua
Salin

1        uint _key = (uint256(_firstByte & 0x0F) << (8*_extraBytes)) +
2            _calldataVal(_fromByte+1, _extraBytes);
3
4        return (_fromByte+_extraBytes+1, cacheRead(_key));
5
6    }  // _readParam // _readParam
7
8
9    // Read n parameters (functions know how many parameters they expect) // Baca n parameter (fungsi tahu berapa banyak parameter yang mereka harapkan)
10    function _readParams(uint _paramNum) internal returns (uint[] memory) {
Tampilkan semua
Salin

1        // The parameters we read // Parameter yang kita baca
2        uint[] memory params = new uint[](_paramNum);
3
4        // Parameters start at byte 4, before that it's the function signature // Parameter dimulai pada byte 4, sebelumnya adalah tanda tangan fungsi
5        uint _atByte = 4;
6
7        for(uint i=0; i<_paramNum; i++) {
8            (_atByte, params[i]) = _readParam(_atByte);
9        }
Tampilkan semua
Salin

1
2        return(params);
3    }   // readParams // readParams
4
5    // For testing _readParams, test reading four parameters // Untuk menguji _readParams, uji membaca empat parameter
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 // fourParam
Tampilkan semua
Salin

1    // Get a value, return bytes that will encode it (using the cache if possible) // Dapatkan nilai, kembalikan byte yang akan mengodenya (menggunakan cache jika memungkinkan)
2    function encodeVal(uint _val) public view returns(bytes memory) {
Salin

1        uint _key = val2key[_val];
2
3        // The value isn't in the cache yet, add it // Nilai belum ada di dalam cache, tambahkan
4        if (_key == 0)
5            return bytes.concat(INTO_CACHE, bytes32(_val));
Salin

1        // If the key is <0x10, return it as a single byte // Jika kunci <0x10, kembalikan sebagai satu byte
2        if (_key < 0x10)
3            return bytes.concat(bytes1(uint8(_key)));
Salin

1        // Two byte value, encoded as 0x1vvv // Nilai dua byte, dikodekan sebagai 0x1vvv
2        if (_key < 0x1000)
3            return bytes.concat(bytes2(uint16(_key) | 0x1000));
Salin

1        // There is probably a clever way to do the following lines as a loop, // Mungkin ada cara cerdas untuk melakukan baris berikut sebagai loop,
2        // but it's a view function so I'm optimizing for programmer time and // tetapi ini adalah fungsi view jadi saya mengoptimalkan untuk waktu programmer dan
3        // simplicity. // kesederhanaan.
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)));
Tampilkan semua
Salin

1        // If we get here, something is wrong. // Jika kita sampai di sini, ada sesuatu yang salah.
2        revert("Error in encodeVal, should not happen");
Salin

1    } // encodeVal // encodeVal
2
3}  // Cache // Cache
Salin

1// SPDX-License-Identifier: UNLICENSED // SPDX-License-Identifier: UNLICENSED
2pragma solidity ^0.8.13;
3
4import "forge-std/Test.sol";
5
6
7// Need to run `forge test -vv` for the console. // Perlu menjalankan `forge test -vv` untuk konsol.
8import "forge-std/console.sol";
Salin

1import "src/Cache.sol";
Salin

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

1    function testCaching() public {
Salin

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);
Salin

1        }
2    }    // testCaching // testCaching
3
4
5    // Cache the same value multiple times, ensure that the key stays // Cache nilai yang sama beberapa kali, pastikan kuncinya tetap
6    // the same // sama
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        }
Tampilkan semua
Salin

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

1    // Read a uint from a memory buffer (to make sure we get back the parameters // Baca uint dari buffer memori (untuk memastikan kita mendapatkan kembali parameter
2    // we sent out) // yang kita kirimkan)
3    function toUint256(bytes memory _bytes, uint256 _start) internal pure
4        returns (uint256)
Salin

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

1
2        return tempUint;
3    }     // toUint256 // toUint256
4
5    // Function signature for fourParams(), courtesy of // Tanda tangan fungsi untuk fourParams(), atas kebaikan
6    // https://www.4byte.directory/signatures/?bytes4_signature=0x3edc1e6d // https://www.4byte.directory/signatures/?bytes4_signature=0x3edc1e6d
7    bytes4 constant FOUR_PARAMS = 0x3edc1e6d;
8
9    // Just some constant values to see we're getting the correct values back // Hanya beberapa nilai konstan untuk melihat kita mendapatkan kembali nilai yang benar
10    uint256 constant VAL_A = 0xDEAD60A7;
11    uint256 constant VAL_B =     0xBEEF;
12    uint256 constant VAL_C =     0x600D;
13    uint256 constant VAL_D = 0x600D60A7;
Tampilkan semua
Salin

1    function testReadParam() public {
Salin

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

1        // First call, the cache is empty // Panggilan pertama, cache kosong
2        _callInput = bytes.concat(
3            FOUR_PARAMS,
Salin

1            // First value, add it to the cache // Nilai pertama, tambahkan ke cache
2            cache.INTO_CACHE(),
3            bytes32(VAL_A),
Salin

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

1        assertEq(_success, true);
Salin

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

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        // Second call, we can use the cache // Panggilan kedua, kita dapat menggunakan cache
2        _callInput = bytes.concat(
3            FOUR_PARAMS,
4
5            // First value in the Cache // Nilai pertama di dalam Cache
6            bytes1(0x01),
Salin

1            // Second value, don't add it to the cache // Nilai kedua, jangan tambahkan ke cache
2            cache.DONT_CACHE(),
3            bytes32(VAL_B),
4
5            // Third and fourth values, same value // Nilai ketiga dan keempat, nilai yang sama
6            bytes1(0x02),
7            bytes1(0x02)
8        );
9        .
10        .
11        .
12    }   // testReadParam // testReadParam
Tampilkan semua
Salin

1    function testEncodeVal() public {
Salin

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 // testEncodeVal
Tampilkan semua
Salin

1    // Test encodeVal when the key is more than a single byte // Uji encodeVal ketika kunci lebih dari satu byte
2    // Maximum three bytes because filling the cache to four bytes takes // Maksimum tiga byte karena mengisi cache hingga empat byte membutuhkan
3    // too long. // waktu terlalu lama.
4    function testEncodeValBig() public {
5        // Put a number of values in the cache. // Masukkan sejumlah nilai ke dalam cache.
6        // To keep things simple, use key n for value n. // Agar tetap sederhana, gunakan kunci n untuk nilai n.
7        for(uint i=1; i<0x1FFF; i++) {
8            cache.cacheWrite(i);
9        }
Tampilkan semua
Salin

1        .
2        .
3        .
4
5        _callInput = bytes.concat(
6            FOUR_PARAMS,
7            cache.encodeVal(0x000F),   // One byte        0x0F // Satu byte        0x0F
8            cache.encodeVal(0x0010),   // Two bytes     0x1010 // Dua byte     0x1010
9            cache.encodeVal(0x0100),   // Two bytes     0x1100 // Dua byte     0x1100
10            cache.encodeVal(0x1000)    // Three bytes 0x201000 // Tiga byte 0x201000
11        );
Tampilkan semua
Salin

1        .
2        .
3        .
4        .
5    }    // testEncodeValBig // testEncodeValBig
6
7
8    // Test what with an excessively small buffer we get a revert // Uji bahwa dengan buffer yang terlalu kecil kita mendapatkan revert
9    function testShortCalldata() public {
Tampilkan semua
Salin

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

1    // Call with cache keys that aren't there
2    function testNoCacheKey() public {
3        .
4        .
5        .
6        _callInput = bytes.concat(
7            FOUR_PARAMS,
8
9            // First value, add it to the cache
10            cache.INTO_CACHE(),
11            bytes32(VAL_A),
12
13            // Second value
14            bytes1(0x0F),
15            bytes2(0x1234),
16            bytes11(0xA10102030405060708090A)
17        );
Tampilkan semua

1        .
2        .
3        .
4    // Test what with an excessively long buffer everything works file // Uji bahwa dengan buffer yang terlalu panjang semuanya berfungsi dengan baik
5    function testLongCalldata() public {
6        address _cacheAddr = address(cache);
7        bool _success;
8        bytes memory _callInput;
9        bytes memory _callOutput;
10
11        // First call, the cache is empty // Panggilan pertama, cache kosong
12        _callInput = bytes.concat(
13            FOUR_PARAMS,
14
15            // First value, add it to the cache // Nilai pertama, tambahkan ke cache
16            cache.INTO_CACHE(), bytes32(VAL_A),
17
18            // Second value, add it to the cache // Nilai kedua, tambahkan ke cache
19            cache.INTO_CACHE(), bytes32(VAL_B),
20
21            // Third value, add it to the cache // Nilai ketiga, tambahkan ke cache
22            cache.INTO_CACHE(), bytes32(VAL_C),
23
24            // Fourth value, add it to the cache // Nilai keempat, tambahkan ke cache
25            cache.INTO_CACHE(), bytes32(VAL_D),
26
27            // And another value for "good luck" // Dan nilai lain untuk "semoga berhasil"
28            bytes4(0x31112233)
29        );
Tampilkan semua
Salin

1        (_success, _callOutput) = _cacheAddr.call(_callInput);
2        assertEq(_success, true);
3        .
4        .
5        .
6    }   // testLongCalldata // testLongCalldata
7
8}        // CacheTest // CacheTest
9
Tampilkan semua
Salin

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

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

1    // Make it easier to call us // Buat lebih mudah untuk memanggil kami
2    // Function signature for writeEntryCached(), courtesy of // Tanda tangan fungsi untuk writeEntryCached(), atas kebaikan
3    // https://www.4byte.directory/signatures/?bytes4_signature=0xe4e4f2d3 // https://www.4byte.directory/signatures/?bytes4_signature=0xe4e4f2d3
4    bytes4 constant public WRITE_ENTRY_CACHED = 0xe4e4f2d3;
Salin

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

1    function testWReadWrite() public {
2        worm.writeEntry(0xDEAD, 0x60A7);
3
4        vm.expectRevert(bytes("entry already written"));
5        worm.writeEntry(0xDEAD, 0xBEEF);
Salin

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

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

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

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);
Tampilkan semua
Salin

1
22. Instal paket yang diperlukan:
3
4   ```sh
5   cd javascript
6   yarn

1
24. Edit `.env` untuk konfigurasi Anda:
3
4   | Parameter           | Nilai                                                                                                                                                               |
5   | ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
6   | MNEMONIC            | Mnemonic untuk akun yang memiliki cukup ETH untuk membayar transaksi. [Anda bisa mendapatkan ETH gratis untuk jaringan Optimism Goerli di sini](https://optimismfaucet.xyz/). |
7   | OPTIMISM_GOERLI_URL | URL ke Optimism Goerli. Titik akhir publik, `https://goerli.optimism.io`, dibatasi kecepatannya tetapi cukup untuk apa yang kita butuhkan di sini                                      |
8
95. Jalankan `index.js`.
10
11   ```sh
12   node index.js
Tampilkan semua

1.
2.
3.
4const main = async () => {
5    const func = await worm.WRITE_ENTRY_CACHED()
6
7    // Need a new key every time // Perlu kunci baru setiap saat
8    const key = await worm.encodeVal(Number(new Date()))

1const val = await worm.encodeVal("0x600D")
2
3// Write an entry // Tulis entri
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    // Read the entry just written // Baca entri yang baru saja ditulis
5    const realKey = '0x' + key.slice(4)  // remove the FF flag // hapus bendera FF
6    const entryRead = await worm.readEntry(realKey)
7    .
8    .
9    .
Tampilkan semua