🧵 #100GündeSolidity 028 : Interface

Interface – Arayüz: Sözleşmeler Arası Etkileşim İçin Bir Anahtar

Solidity, akıllı sözleşmelerin oluşturulması için yaygın olarak kullanılan bir programlama dilidir. Akıllı sözleşmelerin temel amacı, farklı taraflar arasında doğrudan ve güvenli bir şekilde varlık transferi ve işlemlerinin gerçekleştirilmesini sağlamaktır. Ancak, akıllı sözleşmelerin işlevselliğinin artması için, birbirleriyle etkileşim kurmaları gerekmektedir. Solidity’de, diğer akıllı sözleşmelerle etkileşim kurmak için “Interface” adı verilen bir yapı kullanılır. Bu makalede, Solidity’de arayüzlerin tanımı, işlevleri ve kullanımı hakkında detaylı bilgi edineceksiniz.

Arayüzlerin Tanımı

Solidity programlama dilinde, arayüzler, akıllı sözleşmeler arasındaki etkileşimi sağlamak için kullanılan bir sözleşme türüdür. Arayüzler, işlevlerin prototiplerini belirleyerek, diğer sözleşmelerle iletişim kurmak için gerekli olan fonksiyonların imzasını sağlar.

Arayüzler, işlevlerin imzalarını içerir, ancak işlevlerin kendilerine sahip değildir. Bu nedenle, işlevlerin parametreleri, döndürdükleri değerler ve erişim belirteçleri gibi detayları içeren işlev prototipleri yer alır. Arayüzler, diğer sözleşmelerin örneklerini oluşturmak için kullanılır ve bu nedenle kendi kurucularına sahip olmazlar.

Arayüzler, Solidity’de kod yeniden kullanımını teşvik eden ve farklı sözleşmeler arasında entegrasyonu kolaylaştıran önemli bir yapıdır. Ayrıca, arayüzlerin kullanımı, sözleşmeler arasındaki iletişimin sağlanmasını kolaylaştırarak, sözleşmelerin daha modüler ve esnek bir şekilde tasarlanmasını sağlar.

Arayüzlerin tanımlanması, genellikle aşağıdaki örnekteki gibi yapılır:

interface MyInterface {
    function myFunction(uint256 arg1, string calldata arg2) external returns (bool);
}

Bu örnekte, “MyInterface” adlı bir arayüz tanımlanmıştır. Arayüz, “myFunction” adında bir işlev içerir. İşlevin parametreleri “uint256” türünde “arg1” ve “string” türünde “arg2” olup, işlev “bool” türünde bir değer döndürür. Ayrıca, işlev, “external” olarak tanımlanmıştır, bu nedenle, yalnızca diğer sözleşmeler aracılığıyla çağrılabilir.

Arayüzler, Solidity’de kullanılan birçok başka terimle birlikte kullanılır. Örneğin, arayüzler, kalıtım kullanarak diğer arayüzlerden miras alabilir ve ayrıca sözleşmelerde kullanılan “struct” veya “enum” türleri gibi özel türlerin tanımlanmasında da kullanılabilirler.

Sonuç olarak, Solidity’de arayüzler, akıllı sözleşmelerin birbirleriyle etkileşim kurması için kullanılan önemli bir yapıdır. Arayüzler, işlevlerin prototiplerini belirleyerek, diğer sözleşmelerle iletişim kurmak için gerekli olan fonksiyonların imzasını sağlar ve sözleşmeler arasında kod yeniden kullanımını teşvik eder.

İşlevlerin İmzaları

Solidity’de arayüzlerin en önemli özelliklerinden biri, işlevlerin imzalarını içermesidir. İşlevlerin imzaları, işlevin adı, parametreleri, geri dönüş değeri ve erişim belirteçleri gibi ayrıntıları içerir.

Örneğin, aşağıdaki arayüzde, “myFunction” adında bir işlev tanımlanmıştır:

interface MyInterface {
    function myFunction(uint256 arg1, string calldata arg2) external returns (bool);
}

Bu işlevin imzası, “uint256” türünde “arg1” ve “string” türünde “arg2” parametreleri içerir ve “bool” türünde bir değer döndürür. Ayrıca, işlev “external” olarak belirtilmiştir, yani yalnızca diğer sözleşmeler aracılığıyla çağrılabilir.

Arayüzler, işlev imzaları sağladığından, diğer sözleşmeler arasında etkileşim kurmak için kullanılan işlevlerin imzalarını belirleyebilir. Bu nedenle, bir sözleşme diğer bir sözleşmeyle etkileşime geçmek istediğinde, kullanacağı işlevlerin imzasını önceden tanımlanmış bir arayüzde tanımlayabilir.

Örneğin, aşağıdaki örnekte, bir sözleşme “MyInterface” adlı bir arayüzü kullanır ve bu arayüzde tanımlanan “myFunction” işlevini kullanarak başka bir sözleşmeyle etkileşime geçer:

contract MyContract {
    MyInterface otherContract;
    
    constructor(address _otherContractAddress) {
        otherContract = MyInterface(_otherContractAddress);
    }
    
    function callOtherContract(uint256 arg1, string memory arg2) public {
        bool result = otherContract.myFunction(arg1, arg2);
        // do something with the result
    }
}

Bu örnekte, “MyContract” adlı bir sözleşme, “MyInterface” adlı bir arayüzü kullanarak, “otherContract” adlı başka bir sözleşmeyle etkileşime geçer. Sözleşme, “callOtherContract” adında bir işlev içerir ve bu işlev, “otherContract” sözleşmesinin “myFunction” işlevini çağırarak başka bir sözleşmeyle etkileşime geçer.

İşlev imzaları, Solidity’de sözleşmeler arasında etkileşim kurmak için gerekli olan fonksiyonların belirlenmesini sağlar. Bu nedenle, arayüzler, Solidity’de sözleşmeler arasında modüler bir yapı oluşturmak için kullanılır.

İşlevlerin Erişim Belirleyicileri

Solidity’deki fonksiyonlar, erişim belirleyicileri ile tanımlanabilirler. Bu belirleyiciler, fonksiyonun kimler tarafından çağrılabileceğini belirler ve Solidity’nin sözleşme güvenliği açısından önemli bir özelliğidir.

Solidity’de, dört farklı erişim belirleyicisi vardır:

1. public: Bu belirleyici ile tanımlanan fonksiyonlar, herkes tarafından çağrılabilir. Bu, sözleşmenin dışındaki kullanıcılar veya diğer sözleşmeler tarafından fonksiyonun çağrılmasına izin verir.
2. private: Bu belirleyici ile tanımlanan fonksiyonlar, yalnızca aynı sözleşme içerisindeki diğer fonksiyonlar tarafından çağrılabilir. Sözleşmenin dışındaki kullanıcılar veya diğer sözleşmeler tarafından fonksiyonun çağrılmasına izin verilmez.
3. internal: Bu belirleyici ile tanımlanan fonksiyonlar, yalnızca sözleşmenin kendisi veya sözleşmenin türetilmiş sınıfları tarafından çağrılabilir. Sözleşmenin dışındaki kullanıcılar veya diğer sözleşmeler tarafından fonksiyonun çağrılmasına izin verilmez.
4. external: Bu belirleyici ile tanımlanan fonksiyonlar, yalnızca sözleşmenin dışındaki kullanıcılar veya diğer sözleşmeler tarafından çağrılabilir. Sözleşmenin içindeki diğer fonksiyonlar tarafından çağrılmasına izin verilmez.

Arayüzlerin işlevlerinde kullanılabilen erişim belirleyicileri, yalnızca “external” olarak belirlenmiş fonksiyonlardır. Arayüzlerin, yalnızca fonksiyon imzalarını sağlaması gerektiğinden, erişim belirleyicileri burada daha az önemli bir rol oynar.

Örneğin, aşağıdaki örnek, “public” belirleyicisi kullanılarak bir işlev tanımlar:

contract MyContract {
    uint256 public myValue;
    
    function setValue(uint256 _newValue) public {
        myValue = _newValue;
    }
}

Bu sözleşme, “myValue” adlı bir değişken ve “setValue” adlı bir işlev içerir. “myValue” değişkeni, “public” belirleyicisi ile tanımlandığı için, herkes tarafından okunabilir. “setValue” işlevi de “public” belirleyicisi ile tanımlandığı için, herkes tarafından çağrılabilir.

Kurucuların Tanımı

Solidity’de kurucu, bir sözleşmenin oluşturulması sırasında otomatik olarak çağrılan ve sözleşmenin ilk başlatılmasını sağlayan özel bir işlevdir. Kurucu, Solidity’de “constructor” anahtar kelimesi ile tanımlanır.

Bir sözleşmenin kurucusu yalnızca bir kez çağrılabilir ve adı, sözleşmenin adı ile aynı olmalıdır. Kurucu işlevinin imzası, dış dünyayla etkileşim kurabilecek değişkenlerin ve fonksiyonların hazır hale getirilmesi için kullanılır.

Kurucu işlevi, Solidity sözleşmelerinde sıkça kullanılan bir özelliktir. Bu işlev, sözleşmenin ilk başlatılmasını sağlar ve değişkenlerin ilk değerlerini atar. Ayrıca, sözleşmenin diğer işlevlerinin çalışması için gerekli olan önemli yapılandırmaları da gerçekleştirir.

Bir kurucu işlevi, diğer Solidity işlevleri gibi erişim belirleyicileri kullanılarak tanımlanabilir. Kurucu işlevi, “public”, “private”, “internal” veya “external” gibi erişim belirleyicileri kullanarak belirlenebilir.

Örneğin, aşağıdaki örnek, “MyContract” adlı bir sözleşme oluşturur ve bu sözleşmenin kurucu işlevini tanımlar:

pragma solidity ^0.8.0;

contract MyContract {
    uint256 public myValue;

    constructor() {
        myValue = 42;
    }
}

Bu örnekte, “MyContract” adlı bir sözleşme oluşturulur ve “myValue” adlı bir değişken tanımlanır. Kurucu işlevi, “constructor” anahtar kelimesi ile tanımlanır ve sadece “myValue” değişkenine bir başlangıç değeri atar.

Kurucu işlevleri, Solidity’deki sözleşmelerin temel bileşenlerinden biridir. Sözleşme oluşturulurken otomatik olarak çağrılırlar ve sözleşmenin oluşturulması ve yapılandırılması için önemli bir rol oynarlar.

Durum Değişkenlerinin Kısıtlanması

Solidity’de durum değişkenleri, sözleşmenin durumunu tutmak ve değiştirmek için kullanılan değişkenlerdir. Bu değişkenler, sözleşmenin çalışma zamanında durumunu takip etmek için kullanılır. Ancak, Solidity’deki durum değişkenleri, sözleşmenin güvenliğini tehlikeye atan bazı riskler de içerir. Özellikle, kullanıcılardan gelen verilerin doğrulanmadığı veya kötüye kullanıldığı durumlarda söz konusu riskler daha da artar.

Bu nedenle, Solidity’deki durum değişkenlerinin kısıtlanması ve korunması önemlidir. Bunun için, Solidity’de çeşitli teknikler ve yöntemler kullanılabilir. Bazıları şunlardır:

1. Erişim Belirleyicileri Kullanma: Solidity’deki durum değişkenleri, erişim belirleyicileri kullanılarak kısıtlanabilir. Erişim belirleyicileri, değişkenlere kimlerin erişebileceğini belirlemek için kullanılır. Örneğin, “private” erişim belirleyicisi kullanarak bir değişkeni sadece sözleşme içindeki fonksiyonların erişimine açık hale getirebilirsiniz.
2. Fonksiyonların İmzalarını Kullanma: Solidity’deki fonksiyonların imzaları, fonksiyonun parametrelerinin ve dönüş değerlerinin türlerinin belirlenmesini sağlar. Bu imzalar, fonksiyonların durum değişkenlerine erişimini kısıtlayabilir. Örneğin, “pure” veya “view” fonksiyonları yalnızca okuma işlemleri gerçekleştirebilir ve değişkenlere erişemezler.
3. Modifiyer Kullanma: Modifiyerler, Solidity’deki fonksiyonları değiştirmek için kullanılan özel fonksiyonlardır. Modifiyerler, fonksiyonların başlatılması öncesinde belirli koşulların kontrol edilmesini sağlayabilir ve bu sayede durum değişkenlerinin kötüye kullanımını engelleyebilir. Örneğin, “onlyOwner” modifiyeri kullanarak, yalnızca sözleşmenin sahibi olan kişinin belirli bir fonksiyona erişimine izin verebilirsiniz.
4. Sözleşme Mirasını Sınırlama: Solidity’de, bir sözleşme diğer bir sözleşmeden miras alabilir. Ancak, miras veren sözleşmenin durum değişkenleri, miras alan sözleşmenin durum değişkenleri tarafından değiştirilebilir. Bu, sözleşmenin güvenliğini tehlikeye atan bir durumdur.

Kalıtım

Solidity programlama dilinde, kalıtım, bir sözleşmenin başka bir sözleşmeden özelliklerini miras almasına olanak tanır. Bu, kod tekrarını önler ve programcıların daha karmaşık sözleşmeler oluşturmasını kolaylaştırır.

Kalıtım, Solidity’de “is” anahtar kelimesi kullanılarak gerçekleştirilir. Miras veren sözleşme, miras alınan sözleşmeye benzer bir şekilde tanımlanır, ancak “is” anahtar kelimesi ve miras alınan sözleşmenin adı da belirtilir.

Örneğin, aşağıdaki Solidity kodunda, “Animal” sözleşmesi “eat” fonksiyonunu tanımlar ve “Dog” sözleşmesi “Animal” sözleşmesinden kalıtım alır ve aynı zamanda “bark” fonksiyonunu da tanımlar:

pragma solidity ^0.8.0;

contract Animal {
    function eat() public virtual returns (string memory) {
        return "Yum!";
    }
}

contract Dog is Animal {
    function bark() public returns (string memory) {
        return "Woof!";
    }
}

Yukarıdaki kodda, “Dog” sözleşmesi “Animal” sözleşmesinden kalıtım almıştır ve “eat” fonksiyonunu da miras almıştır. Ancak, “Dog” sözleşmesi “bark” fonksiyonunu da tanımlar ve “Animal” sözleşmesinde bu fonksiyon yoktur.

Mirasa alınan sözleşme içindeki fonksiyonlar ve değişkenler, miras alan sözleşmede aynen kullanılabilir. Ancak, miras alan sözleşme, miras veren sözleşmenin fonksiyonlarını veya değişkenlerini değiştirebilir veya üzerine ekleyebilir. Bu sayede, programcılar, miras alınan sözleşmenin özelliklerini özelleştirebilir veya genişletebilirler.

Kalıtım, Solidity’de çoklu kalıtım olarak da uygulanabilir. Bu, bir sözleşmenin birden fazla sözleşmeden özelliklerini miras almasına olanak sağlar. Ancak, Solidity’de çoklu kalıtımın bazı sınırlamaları vardır. Örneğin, bir sözleşme, bir sınıftan sadece bir kez kalıtım alabilir. Bu, Solidity’de ambigüiteyi önlemek için yapılmış bir kısıtlamadır.

Akıllı Sözleşme Örneği İNCELEME

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;

contract Counter {
    uint public count;

    function increment() external {
        count += 1;
    }
}

interface ICounter {
    function count() external view returns (uint);

    function increment() external;
}

contract MyContract {
    function incrementCounter(address _counter) external {
        ICounter(_counter).increment();
    }

    function getCount(address _counter) external view returns (uint) {
        return ICounter(_counter).count();
    }
}

// Uniswap example
interface UniswapV2Factory {
    function getPair(
        address tokenA,
        address tokenB
    ) external view returns (address pair);
}

interface UniswapV2Pair {
    function getReserves()
        external
        view
        returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
}

contract UniswapExample {
    address private factory = 0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f;
    address private dai = 0x6B175474E89094C44Da98b954EedeAC495271d0F;
    address private weth = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;

    function getTokenReserves() external view returns (uint, uint) {
        address pair = UniswapV2Factory(factory).getPair(dai, weth);
        (uint reserve0, uint reserve1, ) = UniswapV2Pair(pair).getReserves();
        return (reserve0, reserve1);
    }
}

Bu akıllı sözleşme örneği, Solidity dilinde arayüzlerin kullanımını göstermektedir.

İlk olarak “Counter” isimli bir sözleşme (contract) tanımlanmıştır. Bu sözleşmede, “count” adında bir uint tipinde durum değişkeni tanımlanmıştır. Ayrıca, “increment” adında bir fonksiyon da yer almaktadır. Bu fonksiyon, “count” değişkenini bir arttırmaktadır.

Daha sonra “ICounter” isimli bir arayüz (interface) tanımlanmıştır. Bu arayüz, “count” ve “increment” adında iki adet fonksiyon içermektedir. “count” fonksiyonu, “uint” tipinde bir değer döndürmektedir ve “increment” fonksiyonu, dışarıdan erişilebilir bir fonksiyondur.

Son olarak “MyContract” isimli bir sözleşme daha tanımlanmıştır. Bu sözleşmede, “incrementCounter” adında bir fonksiyon ve “getCount” adında bir fonksiyon yer almaktadır. “incrementCounter” fonksiyonu, dışarıdan bir adres alarak, bu adres üzerinden “ICounter” arayüzünü kullanarak “increment” fonksiyonunu çağırmaktadır. “getCount” fonksiyonu ise yine dışarıdan bir adres alarak, bu adres üzerinden “ICounter” arayüzünü kullanarak “count” fonksiyonunu çağırmaktadır.

Son olarak, örneğin alt kısmında, “UniswapV2Factory” ve “UniswapV2Pair” isimli iki arayüz tanımlanmıştır. Bu arayüzler, Uniswap protokolünün kullanımına yöneliktir. “UniswapExample” isimli bir sözleşme de tanımlanmıştır. Bu sözleşmede, “getTokenReserves” adında bir fonksiyon yer almaktadır. Bu fonksiyon, UniswapV2Factory arayüzündeki “getPair” fonksiyonunu kullanarak “pair” adında bir adres elde etmektedir. Daha sonra, bu adres üzerinden “UniswapV2Pair” arayüzündeki “getReserves” fonksiyonunu kullanarak, “reserve0” ve “reserve1” adında iki adet uint değeri elde etmektedir. Bu değerler, fonksiyonun geri dönüş değeri olarak döndürülmektedir.

Sonuç Bağlamı

Sonuç olarak, Solidity programlama dilinde “Interface” kavramı, başka bir sözleşmeyle etkileşim kurmak için bir arayüz sağlar. “Interface” tanımı, fonksiyonların imzalarından oluşur ve bu fonksiyonlar sözleşme içinde gerçekleştirilmez. “Interface” arayüzleri, işlevlerin erişim belirleyicilerini sınırlar, durum değişkenleri deklare etmez ve kurucuları içermez. Kalıtım yoluyla bir arayüz diğer arayüzlerden türetilebilir. Bu, akıllı sözleşmelerin birbirleriyle ve diğer dapp’lerle iletişim kurmasını ve birlikte çalışmasını sağlar. “Interface”ler, Solidity programlama dilinde modüler ve yeniden kullanılabilir kodun oluşturulmasına olanak tanır ve işlevlerin yeniden kullanılabilirliğini artırır.

Solidity Programlama Dili Öğrenme yolculuğunuz hakkında daha iyi rehberlik almak için Solidity nedir? Ethereum Akıllı Sözleşmelerinin Dili Rehberi içeriğimize göz atın. Dilerseniz Yeni Başlayanlar için Solidity – Akıllı Sözleşme Geliştirme Hızlandırılmış Kursuna katılın.

Çalışmaya nereden başlayacağım diyenler için Blockchain ​​Developer Olmak İçin Yol Haritası içeriğine de muhakkak bakın.

Gelin aklınızdaki soruları SUPERPEER sohbetinde cevaplayalım.

Bu makaleyi okuduğunuz için teşekkürler! Bana destek olmak isterseniz;

Beni Twitter, Linkedin ve YouTube‘da takip edin.

Kısa bir yorum bırakmayı UNUTMAYIN!