**சாலிடிட்டி** (*solidity*) என்பது எண்ணிம குத்தைகையை உருவாக்கு உதவும் ஒரு நிரல் மொழியாகும்.

பண்புகள்
--------

* சாலிடிட்டி, பிளாக்செயின் தொழில்நுட்பத்தில் இயங்கும் திறன் குத்தகைகளை உருவாக்கப் பயன்படுகின்றது.
* இந்நிரல் மொழி காவின் வுட், கிரிஸ்டியன் ரெயட்வியஸ்னர், அலெக்ஸ் பீரக்சாசி, லியான ஹஸ்கியன், யோச்சி ஹிராய் உள்ளிட்ட பல்வேறு ஈத்தரீயம் உருவாக்குனர்களால், திறன் குத்தகைகள் உருவாக்க கட்டமைக்கப்பட்டது.
* இம்மொழியைனை *\*.sol* என்ற பெயரில் சேமிக்க வேண்டும்.
* இந்நிரல் மொழியினை இணையத்திலோ, கணினியிலோ நிரல்மொழிமாற்றி உதவியுடன் சரிபார்க்க இயலும்.

திறன் குத்தகை எடுத்துக்காட்டு
-----------------------------

சாலிடிட்டி நிரலில் எழுதப்பட்ட ஒரு திறன் குத்தகை எடுத்துக்காட்டு

```
pragma solidity ^0.4.4;

contract Token {

    /// @return total amount of tokens
    function totalSupply() constant returns (uint256 supply) {}

    /// @param \_owner The address from which the balance will be retrieved
    /// @return The balance
    function balanceOf(address \_owner) constant returns (uint256 balance) {}

    /// @notice send `\_value` token to `\_to` from `msg.sender`
    /// @param \_to The address of the recipient
    /// @param \_value The amount of token to be transferred
    /// @return Whether the transfer was successful or not
    function transfer(address \_to, uint256 \_value) returns (bool success) {}

    /// @notice send `\_value` token to `\_to` from `\_from` on the condition it is approved by `\_from`
    /// @param \_from The address of the sender
    /// @param \_to The address of the recipient
    /// @param \_value The amount of token to be transferred
    /// @return Whether the transfer was successful or not
    function transferFrom(address \_from, address \_to, uint256 \_value) returns (bool success) {}

    /// @notice `msg.sender` approves `\_addr` to spend `\_value` tokens
    /// @param \_spender The address of the account able to transfer the tokens
    /// @param \_value The amount of wei to be approved for transfer
    /// @return Whether the approval was successful or not
    function approve(address \_spender, uint256 \_value) returns (bool success) {}

    /// @param \_owner The address of the account owning tokens
    /// @param \_spender The address of the account able to transfer the tokens
    /// @return Amount of remaining tokens allowed to spent
    function allowance(address \_owner, address \_spender) constant returns (uint256 remaining) {}

    event Transfer(address indexed \_from, address indexed \_to, uint256 \_value);
    event Approval(address indexed \_owner, address indexed \_spender, uint256 \_value);
    
}

contract StandardToken is Token {

    function transfer(address \_to, uint256 \_value) returns (bool success) {
        //Default assumes totalSupply can't be over max (2^256 - 1).
        //If your token leaves out totalSupply and can issue more tokens as time goes on, you need to check if it doesn't wrap.
        //Replace the if with this one instead.
        //if (balances[msg.sender] >= \_value && balances[\_to] + \_value > balances[\_to]) {
        if (balances[msg.sender] >= \_value && \_value > 0) {
            balances[msg.sender] -= \_value;
            balances[\_to] += \_value;
            Transfer(msg.sender, \_to, \_value);
            return true;
        } else { return false; }
    }

    function transferFrom(address \_from, address \_to, uint256 \_value) returns (bool success) {
        //same as above. Replace this line with the following if you want to protect against wrapping uints.
        //if (balances[\_from] >= \_value && allowed[\_from][msg.sender] >= \_value && balances[\_to] + \_value > balances[\_to]) {
        if (balances[\_from] >= \_value && allowed[\_from][msg.sender] >= \_value && \_value > 0) {
            balances[\_to] += \_value;
            balances[\_from] -= \_value;
            allowed[\_from][msg.sender] -= \_value;
            Transfer(\_from, \_to, \_value);
            return true;
        } else { return false; }
    }

    function balanceOf(address \_owner) constant returns (uint256 balance) {
        return balances[\_owner];
    }

    function approve(address \_spender, uint256 \_value) returns (bool success) {
        allowed[msg.sender][\_spender] = \_value;
        Approval(msg.sender, \_spender, \_value);
        return true;
    }

    function allowance(address \_owner, address \_spender) constant returns (uint256 remaining) {
      return allowed[\_owner][\_spender];
    }

    mapping (address => uint256) balances;
    mapping (address => mapping (address => uint256)) allowed;
    uint256 public totalSupply;
}

//name this contract whatever you'd like
contract LaxmiCoin is StandardToken {

    function () {
        //if ether is sent to this address, send it back.
        throw;
    }

    /\* Public variables of the token \*/

    /\*
 NOTE:
 The following variables are OPTIONAL vanities. One does not have to include them.
 They allow one to customise the token contract & in no way influences the core functionality.
 Some wallets/interfaces might not even bother to look at this information.
 \*/
    string public name;                   //fancy name: eg Simon Bucks
    uint8 public decimals;                //How many decimals to show. ie. There could 1000 base units with 3 decimals. Meaning 0.980 SBX = 980 base units. It's like comparing 1 wei to 1 ether.
    string public symbol;                 //An identifier: eg SBX
    string public version = 'H1.0';       //human 0.1 standard. Just an arbitrary versioning scheme.

//
// CHANGE THESE VALUES FOR YOUR TOKEN
//

//make sure this function name matches the contract name above. So if you're token is called TutorialToken, make sure the //contract name above is also TutorialToken instead of ERC20Token

    function LaxmiCoin() {
        balances[msg.sender] = 21000000;               // Give the creator all initial tokens (100000 for example)
        totalSupply = 21000000;                        // Update total supply (100000 for example)
        name = "Laxmi Coin";                                   // Set the name for display purposes
        decimals = 0;                            // Amount of decimals for display purposes
        symbol = "LAXMI";                               // Set the symbol for display purposes
    }

    /\* Approves and then calls the receiving contract \*/
    function approveAndCall(address \_spender, uint256 \_value, bytes \_extraData) returns (bool success) {
        allowed[msg.sender][\_spender] = \_value;
        Approval(msg.sender, \_spender, \_value);

        //call the receiveApproval function on the contract you want to be notified. This crafts the function signature manually so one doesn't have to include a contract in here just for this.
        //receiveApproval(address \_from, uint256 \_value, address \_tokenContract, bytes \_extraData)
        //it is assumed that when does this that the call \*should\* succeed, otherwise one would use vanilla approve instead.
        if(!\_spender.call(bytes4(bytes32(sha3("receiveApproval(address,uint256,address,bytes)"))), msg.sender, \_value, this, \_extraData)) { throw; }
        return true;
    }
}

```

உசாத்துணை
---------

1. ↑  Allison, Ian (12 August 2016). "PwC blockchain expert pinpoints sources of ambiguity in smart contracts". *IBTimes*.. பார்த்த நாள்: 14 December 2016.
2. ↑  "SOFE Berlin: Swift unveils blockchain proof-of-concept". *Finextra*. 24 November 2016.. பார்த்த நாள்: 24 November 2016.
3. ↑  Alyssa Hertig (15 September 2016). "Blockchain Veterans Unveil Secure Smart Contracts Framework". *CoinDesk*. 14 December 2016 அன்று பார்க்கப்பட்டது.
4. ↑  Rebecca Campbell (6 September 2016). "Counterparty Brings Ethereum Smart Contracts to the Bitcoin Blockchain". *CCN*. 14 December 2016 அன்று பார்க்கப்பட்டது.
5. ↑  RJ Catalano, one of the core developers, see VoR0220 on github
6. ↑