சாலிடிட்டி
'''சாலிடிட்டி''' (''solidity'') என்பது எண்ணிம குத்தைகையை உருவாக்கு உதவும் ஒரு [[நிரல் மொழி]]யாகும்.&lt;ref name=&quot;IBTimes12AUG2016&quot;&gt;{{cite news|first1=Ian|last1=Allison|date=12 August 2016|url=http://www.ibtimes.co.uk/pwc-blockchain-expert-pinpoints-sources-ambiguity-smart-contracts-1575778|title=PwC blockchain expert pinpoints sources of ambiguity in smart contracts|work=IBTimes|publisher=|type=News |accessdate=14 December 2016}}&lt;/ref&gt; 
 
 == பண்புகள் ==
 * சாலிடிட்டி, [[பிளாக்செயின்]] தொழில்நுட்பத்தில் இயங்கும் [[திறன் குத்தகை]]களை உருவாக்கப் பயன்படுகின்றது.&lt;ref name=&quot;finextra24Nov2016&quot;&gt;{{cite news|first1=|last1=|date=24 November 2016 |url=https://www.finextra.com/newsarticle/29813/sofe-berlin-swift-unveils-blockchain-proof-of-concept|title=SOFE Berlin: Swift unveils blockchain proof-of-concept|work=Finextra|publisher=|type=News|accessdate=24 November 2016}}&lt;/ref&gt;&lt;ref name=&quot;:CoinDesk14Dec2016&quot;&gt;{{cite web|url=http://www.coindesk.com/blockchain-veterans-unveil-secure-smart-contracts-framework/|title=Blockchain Veterans Unveil Secure Smart Contracts Framework|author=Alyssa Hertig|date=15 September 2016|work=CoinDesk|accessdate=14 December 2016}}&lt;/ref&gt;&lt;ref name=&quot;:CCN09062016&quot;&gt;{{cite web|url=https://www.cryptocoinsnews.com/counterparty-brings-ethereum-smart-contracts-to-the-bitcoin-blockchain/|title=Counterparty Brings Ethereum Smart Contracts to the Bitcoin Blockchain|author=Rebecca Campbell|date=6 September 2016|work=CCN|accessdate=14 December 2016}}&lt;/ref&gt;
 * இந்நிரல் மொழி காவின் வுட், கிரிஸ்டியன் ரெயட்வியஸ்னர், அலெக்ஸ் பீரக்சாசி, லியான ஹஸ்கியன், யோச்சி ஹிராய் உள்ளிட்ட பல்வேறு [[ஈத்தரீயம்]] உருவாக்குனர்களால், திறன் குத்தகைகள் உருவாக்க கட்டமைக்கப்பட்டது.
 * இம்மொழியைனை ''*.sol'' என்ற பெயரில் சேமிக்க வேண்டும்.
 * இந்நிரல் மொழியினை இணையத்திலோ, கணினியிலோ [[நிரல்மொழிமாற்றி]] உதவியுடன் சரிபார்க்க இயலும்.
 
 == திறன் குத்தகை எடுத்துக்காட்டு ==
 சாலிடிட்டி நிரலில் எழுதப்பட்ட ஒரு திறன் குத்தகை எடுத்துக்காட்டு&lt;ref&gt;RJ Catalano, one of the core developers, see VoR0220 on github&lt;/ref&gt;{{r|Bhargavan-2016-08-27}}&lt;syntaxhighlight lang=&quot;js&quot;&gt;
 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] &gt;= _value &amp;&amp; balances[_to] + _value &gt; balances[_to]) {
         if (balances[msg.sender] &gt;= _value &amp;&amp; _value &gt; 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] &gt;= _value &amp;&amp; allowed[_from][msg.sender] &gt;= _value &amp;&amp; balances[_to] + _value &gt; balances[_to]) {
         if (balances[_from] &gt;= _value &amp;&amp; allowed[_from][msg.sender] &gt;= _value &amp;&amp; _value &gt; 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 =&gt; uint256) balances;
     mapping (address =&gt; mapping (address =&gt; 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 &amp; 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 = &quot;Laxmi Coin&quot;;                                   // Set the name for display purposes
         decimals = 0;                            // Amount of decimals for display purposes
         symbol = &quot;LAXMI&quot;;                               // 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(&quot;receiveApproval(address,uint256,address,bytes)&quot;))), msg.sender, _value, this, _extraData)) { throw; }
         return true;
     }
 }
 &lt;/syntaxhighlight&gt;
 
 == உசாத்துணை ==
 {{Reflist|30em
 &lt;ref name        = Allison-2016-12-20&gt;
 {{cite web
  | url           = http://www.ibtimes.co.uk/blockchain-big-data-worth-watching-2017-1596721
  | date          = 20 December 2016
  | title         = Blockchain and big data worth watching in the coming year
  | department    = Business
  | website       = International Business Times
  | language      = en
  | access-date   = 2017-09-28
  | archive-url   =
  |url-status=| archive-date  =
 }}&lt;/ref&gt;
 * [http://cat.lib.unimelb.edu.au/search~S42?/aInternational+Conference+on+Applicable+Algebra%2C+Error-Correcting+Codes%2C+Combinatorics+and+Computer+Algebra%2C+AAECC+%284+%3A+1986+-+26-09-1986+%3A+Karlsruhe%2C+FRG%29/ainternational+conference+on+applicable+algebra+error+correcting+codes+combinatorics+and+computer+algebra+aaecc++++++++4+++++1/47,-1,0,B/browse International Conference on Applications of Natural Language to Information Systems (13th : 2008 : London, England)], NLDB 2008, London, UK, 24–27 June 2008 : proceedings / Epaminondas Kapetanios, Vijayan Sugumaran, Myra Spiliopoulou (eds.), ISBN 978-3-540-69857-9
 &lt;ref name        = Bhargavan-2016-08-27&gt;
 {{cite journal
  | url           = http://research.microsoft.com/en-us/um/people/nswamy/papers/solidether.pdf
  | last1         = Schneier
  | first1        = Karthikeyan
  | last2         = Schneier
  | first2        = Antoine
  | last3         = Bhargavan
  | first3        = Cedric
  | last4         = Delignat-Lavaud
  | first4        = Anitha
  | last5         = Fournet
  | first5        = Gollamudi
  | last6         = Schneier
  | first6        = Bruce
  | last7         = Rastogi
  | first7        = Nadim
  | last8         = Sibut-Pinote
  | first8        = Aseem
  | last9         = Rastogi1
  | first9        = Thomas
  | last10         = Swamy
  | first10        = Nikhil
  | last11         = Zanella-Beguelin
  | first11        = Santiago
  | date          = 27 August 2016
  | title         = Short Paper: Formal Verification of Smart Contracts
  | journal       = Microsoft Research, French Institute for Research in Computer Science and Automation, Harvard University
  | language      = en
  | archive-url   = https://web.archive.org/web/20160827092146/http://research.microsoft.com/en-us/um/people/nswamy/papers/solidether.pdf
  |url-status=| archive-date  = 23 August 2017
 }}&lt;/ref&gt;}}