---
title: "Solidity Syntax - Contracts, Interface, Events, Libraries"
description: "In this tutorial, we will explore the syntax for contracts, contract inheritance, abstract contracts, interfaces, events, and libraries in Solidity."
last_updated: 2026-08-19
---

# Solidity Syntax - Contracts, Interface, Events, Libraries

In this tutorial, we will explore the syntax for contracts, contract inheritance, abstract contracts, interfaces, events, and libraries in Solidity.

## **Contracts**

In Solidity, a contract is a collection of functions and data (state variables) that resides at a specific address on the Ethereum blockchain. A contract can interact with other contracts, receive Ether, and send Ether to other contracts.

### **Creating Contracts Using `new`**

To create a contract from another contract, you can use the **`new`** keyword. The source of the contract has to be known in advance. Here's an example:

```solidity
contract A {
    function add(uint _a, uint _b) returns (uint) {
        return _a + _b;
    }
}

contract C {
    address a;

    function f(uint _a) {
        a = new A();
    }
}
```

### **Contract Inheritance**

Solidity supports multiple inheritance and polymorphism. Inheritance allows you to create new contracts based on existing contracts, inheriting their functions and state variables.

```solidity
contract owned {
    function owned() { owner = msg.sender; }
    address owner;
}

contract mortal is owned {
    function kill() {
        if (msg.sender == owner) selfdestruct(owner);
    }
}

contract final is mortal {
    function kill() {
        super.kill(); // Calls kill() of mortal.
    }
}

```

### Multiple Inheritance

You can inherit from multiple contracts in Solidity:

```solidity
contract A {}
contract B {}
contract C is A, B {}
```

### Constructor of Base Class

If a base class has a constructor, you need to call it explicitly in the derived contract:

```solidity
contract A {
    uint a;
    constructor(uint _a) { a = _a; }
}

contract B is A(1) {
    constructor(uint _b) A(_b) {
    }
}
```

### **Abstract Contracts**

An abstract contract is a contract that contains implemented and non-implemented functions. Such contracts cannot be compiled, but they can be used as base contracts.

```solidity
pragma solidity ^0.4.0;

contract A {
    function C() returns (bytes32);
}

contract B is A {
    function C() returns (bytes32) { return "c"; }
}
```

## **Interface**

An interface is similar to an abstract contract, but it has restrictions. Interfaces cannot have any functions implemented, inherit other contracts or interfaces, define constructors, variables, structs, or enums.

```solidity
pragma solidity ^0.4.11;

interface Token {
    function transfer(address recipient, uint amount);
}
```

## **Events**

Events are a way to emit information from the contract, allowing other programs and the front-end to listen to them. An event is defined using the **`event`** keyword and can have up to three parameters indexed. Indexing allows the parameters to be searched for, while non-indexed parameters are stored in the log data.

Here's an example of an event that emits a deposit with the depositor address, deposit ID, and value:

```solidity
pragma solidity ^0.4.0;

contract ClientReceipt {
    event Deposit(
        address indexed _from,
        bytes32 indexed _id,
        uint _value
    );

    function deposit(bytes32 _id) payable {
        emit Deposit(msg.sender, _id, msg.value);
    }
}

```

### Libraries

Libraries are similar to contracts, but they are deployed only once at a specific address, and their code is used with **`delegatecall`** (**`callcode`**). A library can be called from a contract, and its code will be executed in the context of the calling contract.

Here's an example of a library that provides an add function:

```solidity
solidityCopy code
library Arithmatic {
    function add(uint _a, uint _b) returns (uint) {
        return _a + _b;
    }
}

contract C {
    uint sum;

    function f() {
        sum = Arithmatic.add(2, 3);
    }
}
```

In the above example, **`Arithmatic`** is a library that contains an **`add`** function. The **`add`** function is called from the **`C`** contract, and the result is stored in the **`sum`** variable.