Berinteraksi dengan kontrak lain dari Solidity

Pada tutorial sebelumnya kita telah banyak belajar cara menerapkan kontrak pintar pertama Anda dan menambahkan beberapa fitur ke dalamnya seperti mengontrol akses dengan pengubah (modifier) (opens in a new tab) atau penanganan kesalahan di Solidity (opens in a new tab). Pada tutorial ini kita akan belajar cara menerapkan kontrak pintar dari kontrak yang sudah ada dan berinteraksi dengannya.

Kita akan membuat kontrak yang memungkinkan siapa saja untuk memiliki kontrak pintar Counter mereka sendiri dengan membuat pabrik (factory) untuknya, namanya adalah CounterFactory. Pertama, berikut adalah kode dari kontrak pintar Counter awal kita:

1pragma solidity 0.5.17;
2
3contract Counter {
4
5    uint256 private _count;
6    address private _owner;
7    address private _factory;
8
9
10     modifier onlyOwner(address caller) {
11        require(caller == _owner, "You're not the owner of the contract");
12        _;
13    }
14
15    modifier onlyFactory() {
16        require(msg.sender == _factory, "You need to use the factory");
17        _;
18    }
19
20     constructor(address owner) public {
21        _owner = owner;
22        _factory = msg.sender;
23    }
24
25     function getCount() public view returns (uint256) {
26        return _count;
27    }
28
29    function increment(address caller) public onlyFactory onlyOwner(caller) {
30        _count++;
31    }
32
33}
Tampilkan semua
Salin

Perhatikan bahwa kita sedikit memodifikasi kode kontrak untuk melacak alamat pabrik dan alamat pemilik kontrak. Saat Anda memanggil kode kontrak dari kontrak lain, msg.sender akan merujuk ke alamat pabrik kontrak kita. Ini adalah poin yang sangat penting untuk dipahami karena menggunakan kontrak untuk berinteraksi dengan kontrak lain adalah praktik yang umum. Oleh karena itu, Anda harus memperhatikan siapa pengirimnya dalam kasus-kasus yang kompleks.

Untuk ini kita juga menambahkan pengubah onlyFactory yang memastikan bahwa fungsi pengubah status hanya dapat dipanggil oleh pabrik yang akan meneruskan pemanggil asli sebagai parameter.

Di dalam CounterFactory baru kita yang akan mengelola semua Counter lainnya, kita akan menambahkan pemetaan (mapping) yang akan mengaitkan pemilik dengan alamat kontrak counter-nya:

1mapping(address => Counter) _counters;
Salin

Di Ethereum, pemetaan setara dengan objek dalam javascript, mereka memungkinkan untuk memetakan kunci tipe A ke nilai tipe B. Dalam hal ini kita memetakan alamat pemilik dengan instansiasi Counter-nya.

Menginstansiasi Counter baru untuk seseorang akan terlihat seperti ini:

1  function createCounter() public {
2      require (_counters[msg.sender] == Counter(0));
3      _counters[msg.sender] = new Counter(msg.sender);
4  }
Salin

Kita pertama-tama memeriksa apakah orang tersebut sudah memiliki counter. Jika dia belum memiliki counter, kita menginstansiasi counter baru dengan meneruskan alamatnya ke konstruktor Counter dan menetapkan instansiasi yang baru dibuat ke pemetaan.

Untuk mendapatkan hitungan dari Counter tertentu, akan terlihat seperti ini:

1function getCount(address account) public view returns (uint256) {
2    require (_counters[account] != Counter(0));
3    return (_counters[account].getCount());
4}
5
6function getMyCount() public view returns (uint256) {
7    return (getCount(msg.sender));
8}
Salin

Fungsi pertama memeriksa apakah kontrak Counter ada untuk alamat yang diberikan dan kemudian memanggil metode getCount dari instansiasi tersebut. Fungsi kedua: getMyCount hanyalah jalan pintas untuk meneruskan msg.sender secara langsung ke fungsi getCount.

Fungsi increment cukup mirip tetapi meneruskan pengirim transaksi asli ke kontrak Counter:

1function increment() public {
2      require (_counters[msg.sender] != Counter(0));
3      Counter(_counters[msg.sender]).increment(msg.sender);
4  }
Salin

Perhatikan bahwa jika dipanggil terlalu sering, counter kita mungkin bisa menjadi korban overflow. Anda harus menggunakan pustaka SafeMath (opens in a new tab) sebanyak mungkin untuk melindungi dari kemungkinan kasus ini.

Untuk menerapkan kontrak kita, Anda perlu menyediakan kode CounterFactory dan Counter. Saat menerapkan misalnya di Remix, Anda harus memilih CounterFactory.

Berikut adalah kode lengkapnya:

1pragma solidity 0.5.17;
2
3contract Counter {
4
5    uint256 private _count;
6    address private _owner;
7    address private _factory;
8
9
10     modifier onlyOwner(address caller) {
11        require(caller == _owner, "You're not the owner of the contract");
12        _;
13    }
14
15    modifier onlyFactory() {
16        require(msg.sender == _factory, "You need to use the factory");
17        _;
18    }
19
20     constructor(address owner) public {
21        _owner = owner;
22        _factory = msg.sender;
23    }
24
25     function getCount() public view returns (uint256) {
26        return _count;
27    }
28
29    function increment(address caller) public onlyFactory onlyOwner(caller) {
30        _count++;
31    }
32
33}
34
35contract CounterFactory {
36
37    mapping(address => Counter) _counters;
38
39    function createCounter() public {
40        require (_counters[msg.sender] == Counter(0));
41        _counters[msg.sender] = new Counter(msg.sender);
42    }
43
44    function increment() public {
45        require (_counters[msg.sender] != Counter(0));
46        Counter(_counters[msg.sender]).increment(msg.sender);
47    }
48
49    function getCount(address account) public view returns (uint256) {
50        require (_counters[account] != Counter(0));
51        return (_counters[account].getCount());
52    }
53
54    function getMyCount() public view returns (uint256) {
55        return (getCount(msg.sender));
56    }
57
58}
Tampilkan semua
Salin

Setelah mengompilasi, di bagian penerapan Remix Anda akan memilih pabrik yang akan diterapkan:

Kemudian Anda dapat bermain dengan pabrik kontrak Anda dan memeriksa perubahan nilainya. Jika Anda ingin memanggil kontrak pintar dari alamat yang berbeda, Anda perlu mengubah alamat di pilihan Akun (Account) pada Remix.

Pembaruan terakhir halaman: 15 Agustus 2023

n (opens in a new tab)

m (opens in a new tab)

w (opens in a new tab)

+2

Lihat kontributor