Available on Google PlayApp Store

Solidity - Solidity

top 10 solidity issuesLearn the Solidity programming language and start developing for the blockchainLearn Solidity: Basics of Solidity By ExampleLearn X in Y minutes Where X=Solidity Get the code: learnSolidity.sol Solidity lets you program on Ethereum, ablockchain-based virtual machine that allows the creation andexecution of smart contracts, without requiring centralized or trusted parties.Solidity is a statically typed, contract programming language that hassimilarities to Javascript and C. Like objects in OOP, each contract containsstate variables, functions, and common data types. Contract-specific featuresinclude modifier (guard) clauses, event notifiers for listeners, and customglobal variables.Some Ethereum contract examples include crowdfunding, voting, decentralized finance, and blind auctions.There is a high risk and high cost of errors in Solidity code, so you must be very careful to testand slowly rollout. WITH THE RAPID CHANGES IN ETHEREUM, THIS DOCUMENT IS UNLIKELY TO STAY UP TODATE, SO YOU SHOULD FOLLOW THE SOLIDITY CHAT ROOM AND ETHEREUM BLOG FOR THE LATEST. ALL CODE HERE ISPROVIDED AS IS, WITH SUBSTANTIAL RISK OF ERRORS OR DEPRECATED CODE PATTERNS.Unlike other code, you may also need to add in design patterns like pausing, deprecation, andthrottling usage to reduce risk. This document primarily discusses syntax, and so excludes manypopular design patterns.As Solidity and Ethereum are under active development, experimental or betafeatures are typically marked, and subject to change. Pull requests welcome.Working with Remix and MetamaskOne of the easiest ways to build, deploy, and test solidity code is by using the:Remix Web IDE Metamask wallet.To get started, download the Metamask Browser Extension. Once installed, we will be working with Remix. The below code will be pre-loaded, but before we head over there, let’s look at a few tips to get started with remix. Load it all by hitting this link.Choose the Solidity compilerOpen the file loaded by that linkCompile the fileDeploy Play with contractsYou’ve deployed your first contract! Congrats!You can test out and play with the functions defined. Check out the comments to learn about what each does. Working on a testnetDeploying and testing on a testnet is the most accurate way to test your smart contracts in solidity. To do this let’s first get some testnet ETH from the Kovan testnet. Pop into this Gitter Channel and drop your metamask address in.In your metamask, you’ll want to change to the Kovan testnet. You’ll be given some free test Ethereum. Ethereum is needed to deploy smart contracts when working with a testnet. In the previous example, we didn’t use a testnet, we deployed to a fake virtual environment. When working with a testnet, we can actually see and interact with our contracts in a persistent manner. To deploy to a testnet, on the #4 Deploy step, change your environment to injected web3.This will use whatever network is currently selected in your metamask as the network to deploy to. For now, please continue to use the Javascript VM unless instructed otherwise. When you deploy to a testnet, metamask will pop up to ask you to “confirm” the transaction. Hit yes, and after a delay, you’ll get the same contract interface at the bottom of your screen. // First, a simple Bank contract// Allows deposits, withdrawals, and balance checks// simple_bank.sol (note .sol extension)/* **** START EXAMPLE **** */// Declare the source file compiler versionpragma solidity ^0.6.6;// Start with Natspec comment (the three slashes)// used for documentation - and as descriptive data for UI elements/actions/// @title SimpleBank/// @author nemild/* 'contract' has similarities to 'class' in other languages (class variables,inheritance, etc.) */contract SimpleBank { // CapWords // Declare state variables outside function, persist through life of contract // dictionary that maps addresses to balances // always be careful about overflow attacks with numbers mapping (address => uint) private balances; // "private" means that other contracts can't directly query balances // but data is still viewable to other parties on blockchain address public owner; // 'public' makes externally readable (not writeable) by users or contracts // Events - publicize actions to external listeners event LogDepositMade(address accountAddress, uint amount); // Constructor, can receive one or many variables here; only one allowed constructor() public { // msg provides details about the message that's sent to the contract // msg.sender is contract caller (address of contract creator) owner = msg.sender; } /// @notice Deposit ether into bank /// @return The balance of the user after the deposit is made function deposit() public payable returns (uint) { // Use 'require' to test user inputs, 'assert' for internal invariants // Here we are making sure that there isn't an overflow issue require((balances[msg.sender] + msg.value) >= balances[msg.sender]); balances[msg.sender] += msg.value; // no "this." or "self." required with state variable // all values set to data type's initial value by default emit LogDepositMade(msg.sender, msg.value); // fire event return balances[msg.sender]; } /// @notice Withdraw ether from bank /// @dev This does not return any excess ether sent to it /// @param withdrawAmount amount you want to withdraw /// @return remainingBal function withdraw(uint withdrawAmount) public returns (uint remainingBal) { require(withdrawAmount = a); // assert tests for internal invariants; require is used for user inputs// For more examples of common arithmetic issues, see Zeppelin's SafeMath library// https://github.com/OpenZeppelin/zeppelin-solidity/blob/master/contracts/math/SafeMath.sol// No random functions built in, you can get a pseduo-random number by hashing the current blockhash, or get a truly random number using something like Chainlink VRF. // https://docs.chain.link/docs/get-a-random-number// Type castingint x = int(b);bool b = true; // or do 'var b = true;' for inferred typing// Addresses - holds 20 byte/160 bit Ethereum addresses// No arithmetic allowedaddress public owner;// Types of accounts:// Contract account: address set on create (func of creator address, num transactions sent)// External Account: (person/external entity): address created from public key// Add 'public' field to indicate publicly/externally accessible// a getter is automatically created, but NOT a setter// All addresses can be sent etherowner.transfer(SOME_BALANCE); // fails and reverts on failure// Can also do a lower level .send call, which returns a false if it failedif (owner.send) {} // REMEMBER: wrap send in 'if', as contract addresses have// functions executed on send and these can fail// Also, make sure to deduct balances BEFORE attempting a send, as there is a risk of a recursive// call that can drain the contract// Can check balanceowner.balance; // the balance of the owner (user or contract)// Bytes available from 1 to 32byte a; // byte is same as bytes1bytes2 b;bytes32 c;// Dynamically sized bytesbytes m; // A special array, same as byte[] array (but packed tightly)// More expensive than byte1-byte32, so use those when possible// same as bytes, but does not allow length or index access (for now)string n = "hello"; // stored in UTF8, note double quotes, not single// string utility functions to be added in future// prefer bytes32/bytes, as UTF8 uses more storage// Type inference// var does inferred typing based on first assignment,// can't be used in functions parametersvar a = true;// use carefully, inference may provide wrong type// e.g., an int8, when a counter needs to be int16// var can be used to assign function to variablefunction a(uint x) returns (uint) { return x * 2;}var f = a;f(22); // call// by default, all values are set to 0 on instantiation// Delete can be called on most types// (does NOT destroy value, but sets value to 0, the initial value)delete x;// Destructuring/Tuples(x, y) = (2, 7); // assign/swap multiple values// 2. DATA STRUCTURES// Arraysbytes32[5] nicknames; // static arraybytes32[] names; // dynamic arrayuint newLength = names.push("John"); // adding returns new length of the array// Lengthnames.length; // get lengthnames.length = 1; // lengths can be set (for dynamic arrays in storage only)// multidimensional arrayuint[][5] x; // arr with 5 dynamic array elements (opp order of most languages)// Dictionaries (any type to any other type)mapping (string => uint) public balances;balances["charles"] = 1;// balances["ada"] result is 0, all non-set key values return zeroes// 'public' allows following from another contractcontractName.balances("charles"); // returns 1// 'public' created a getter (but not setter) like the following:function balances(string _account) returns (uint balance) { return balances[_account];}// Nested mappingsmapping (address => mapping (address => uint)) public custodians;// To deletedelete balances["John"];delete balances; // sets all elements to 0// Unlike other languages, CANNOT iterate through all elements in// mapping, without knowing source keys - can build data structure// on top to do this// Structsstruct Bank { address owner; uint balance;}Bank b = Bank({ owner: msg.sender, balance: 5});// orBank c = Bank(msg.sender, 5);c.balance = 5; // set to new valuedelete b;// sets to initial value, set all variables in struct to 0, except mappings// Enumsenum State { Created, Locked, Inactive }; // often used for state machineState public state; // Declare variable from enumstate = State.Created;// enums can be explicitly converted to intsuint createdState = uint(State.Created); // 0// Data locations: Memory vs. storage vs. calldata - all complex types (arrays,// structs) have a data location// 'memory' does not persist, 'storage' does// Default is 'storage' for local and state variables; 'memory' for func params// stack holds small local variables// for most types, can explicitly set which data location to use// 3. Simple operators// Comparisons, bit operators and arithmetic operators are provided// exponentiation: **// exclusive or: ^// bitwise negation: ~// 4. Global Variables of note// ** this **this; // address of contract// often used at end of contract life to transfer remaining balance to partythis.balance;this.someFunction(); // calls func externally via call, not via internal jump// ** msg - Current message received by the contract ** **msg.sender; // address of sendermsg.value; // amount of ether provided to this contract in wei, the function should be marked "payable"msg.data; // bytes, complete call datamsg.gas; // remaining gas// ** tx - This transaction **tx.origin; // address of sender of the transactiontx.gasprice; // gas price of the transaction// ** block - Information about current block **now; // current time (approximately), alias for block.timestamp (uses Unix time)// Note that this can be manipulated by miners, so use carefullyblock.number; // current block numberblock.difficulty; // current block difficultyblock.blockhash(1); // returns bytes32, only works for most recent 256 blocksblock.gasLimit();// ** storage - Persistent storage hash **storage['abc'] = 'def'; // maps 256 bit words to 256 bit words// 5. FUNCTIONS AND MORE// A. Functions// Simple functionfunction increment(uint x) returns (uint) { x += 1; return x;}// Functions can return many arguments,// and by specifying returned arguments name explicit return is not neededfunction increment(uint x, uint y) returns (uint x, uint y) { x += 1; y += 1;}// Call previous functionuint (a,b) = increment(1,1);// 'view' (alias for 'constant')// indicates that function does not/cannot change persistent vars// View function execute locally, not on blockchain// Noted: constant keyword will soon be deprecated.uint y = 1;function increment(uint x) view returns (uint x) { x += 1; y += 1; // this line would fail // y is a state variable, and can't be changed in a view function}// 'pure' is more strict than 'view' or 'constant', and does not// even allow reading of state vars// The exact rules are more complicated, so see more about// view/pure:// http://solidity.readthedocs.io/en/develop/contracts.html#view-functions// 'Function Visibility specifiers'// These can be placed where 'view' is, including:// public - visible externally and internally (default for function)// external - only visible externally (including a call made with this.)// private - only visible in the current contract// internal - only visible in current contract, and those deriving from it// Generally, a good idea to mark each function explicitly// Functions hoisted - and can assign a function to a variablefunction a() { var z = b; z();}function b() {}// All functions that receive ether must be marked 'payable'function depositEther() public payable { balances[msg.sender] += msg.value;}// Prefer loops to recursion (max call stack depth is 1024)// Also, don't setup loops that you haven't bounded,// as this can hit the gas limit// B. Events// Events are notify external parties; easy to search and// access events from outside blockchain (with lightweight clients)// typically declare after contract parameters// Typically, capitalized - and add Log in front to be explicit and prevent confusion// with a function call// Declareevent LogSent(address indexed from, address indexed to, uint amount); // note capital first letter// CallLogSent(from, to, amount);/**For an external party (a contract or external entity), to watch usingthe Web3 Javascript library:// The following is Javascript code, not Solidity codeCoin.LogSent().watch({}, '', function(error, result) { if (!error) { console.log("Coin transfer: " + result.args.amount + " coins were sent from " + result.args.from + " to " + result.args.to + "."); console.log("Balances now:\n" + "Sender: " + Coin.balances.call(result.args.from) + "Receiver: " + Coin.balances.call(result.args.to)); }}**/// Common paradigm for one contract to depend on another (e.g., a// contract that depends on current exchange rate provided by another)// C. Modifiers// Modifiers validate inputs to functions such as minimal balance or user auth;// similar to guard clause in other languages// '_' (underscore) often included as last line in body, and indicates// function being called should be placed theremodifier onlyAfter(uint _time) { require (now >= _time); _; }modifier onlyOwner { require(msg.sender == owner); _; }// commonly used with state machinesmodifier onlyIfStateA (State currState) { require(currState == State.A); _; }// Append right after function declarationfunction changeOwner(newOwner)onlyAfter(someTime)onlyOwner()onlyIfState(State.A){ owner = newOwner;}// underscore can be included before end of body,// but explicitly returning will skip, so use carefullymodifier checkValue(uint amount) { _; if (msg.value > amount) { uint amountToRefund = amount - msg.value; msg.sender.transfer(amountToRefund); }}// 6. BRANCHING AND LOOPS// All basic logic blocks work - including if/else, for, while, break, continue// return - but no switch// Syntax same as javascript, but no type conversion from non-boolean// to boolean (comparison operators must be used to get the boolean val)// For loops that are determined by user behavior, be careful - as contracts have a maximal// amount of gas for a block of code - and will fail if that is exceeded// For example:for(uint x = 0; x minimumToRaise) { state = State.Successful; payOut(); // could incentivize sender who initiated state change here } else if ( now > raiseBy ) { state = State.ExpiredRefund; // backers can now collect refunds by calling getRefund(id) } completeAt = now; } function payOut() public inState(State.Successful) { fundRecipient.transfer(address(this).balance); LogWinnerPaid(fundRecipient); } function getRefund(uint256 id) inState(State.ExpiredRefund) public returns(bool) { require(contributions.length > id && id >= 0 && contributions[id].amount != 0 ); uint256 amountToRefund = contributions[id].amount; contributions[id].amount = 0; contributions[id].contributor.transfer(amountToRefund); return true; } function removeContract() public isCreator() atEndOfLifecycle() { selfdestruct(msg.sender); // creator gets all money that hasn't be claimed }}// ** END EXAMPLE **Some more functions. // 10. OTHER NATIVE FUNCTIONS// Currency units// Currency is defined using wei, smallest unit of Etheruint minAmount = 1 wei;uint a = 1 finney; // 1 ether == 1000 finney// Other units, see: http://ether.fund/tool/converter// Time units1 == 1 second1 minutes == 60 seconds// Can multiply a variable times unit, as units are not stored in a variableuint x = 5;(x * 1 days); // 5 days// Careful about leap seconds/years with equality statements for time// (instead, prefer greater than/less than)// Cryptography// All strings passed are concatenated before hash actionsha3("ab", "cd");ripemd160("abc");sha256("def");// 11. SECURITY// Bugs can be disastrous in Ethereum contracts - and even popular patterns in Solidity,// may be found to be antipatterns// See security links at the end of this doc// 12. LOW LEVEL FUNCTIONS// call - low level, not often used, does not provide type safetysuccessBoolean = someContractAddress.call('function_name', 'arg1', 'arg2');// callcode - Code at target address executed in *context* of calling contract// provides library functionalitysomeContractAddress.callcode('function_name');// 13. STYLE NOTES// Based on Python's PEP8 style guide// Full Style guide: http://solidity.readthedocs.io/en/develop/style-guide.html// Quick summary:// 4 spaces for indentation// Two lines separate contract declarations (and other top level declarations)// Avoid extraneous spaces in parentheses// Can omit curly braces for one line statement (if, for, etc)// else should be placed on own line// 14. NATSPEC COMMENTS// used for documentation, commenting, and external UIs// Contract natspec - always above contract definition/// @title Contract title/// @author Author name// Function natspec/// @notice information about what function does; shown when function to execute/// @dev Function documentation for developer// Function parameter/return value natspec/// @param someParam Some description of what the param does/// @return Description of the return valueAdditional resourcesSolidity DocsChainlink Beginner TutorialsSmart Contract Best PracticesSuperblocks Lab - Browser based IDE for SolidityEthFiddle - The JsFiddle for SolidityBrowser-based Solidity EditorGitter Solidity Chat roomModular design strategies for Ethereum ContractsChainlink DocumentationSmart Contract Development FrameworksHardhatBrownieTruffleImportant librariesZeppelin: Libraries that provide common contract patterns (crowdfuding, safemath, etc)Chainlink: Code that allows you to interact with external dataSample contractsDapp BinDefi ExampleSolidity Baby Step ContractsConsenSys ContractsState of DappsSecurityThinking About Smart Contract SecuritySmart Contract SecurityHacking Distributed BlogStyleSolidity Style Guide: Ethereum’s style guide is heavily derived from Python’s PEP 8 style guide.EditorsRemixEmacs Solidity ModeVim SolidityEditor Snippets (Ultisnips format)Future To DosNew keywords: protected, inheritableList of common design patterns (throttling, RNG, version upgrade)Common security anti patternsFeel free to send a pull request with any edits - or email nemild -/at-/ gmail Got a suggestion? A correction, perhaps? Open an Issue on the Github Repo, or make a pull request yourself! Originally contributed by Nemil Dalal, and updated by 21 contributor(s). © 2023 Nemil Dalal, Joseph Chow, Bhoomtawath Plinsut, Shooter, Patrick Collins Working with Remix and MetamaskSolidity FundamentalsAll Parts in OrderHow To Learn Solidity: The Ultimate Ethereum Coding TutorialSolidity Tutorial – A Detailed IntroductionSolidity - Tutorial#SOLIDITYSOLIDITY - 101 (PART 1)solidity tutorialSolidity in BlockchainThe Answer is Blowing in the Wind…Solidity Programming Essentials: A beginner's guide to build smart contracts for Ethereum and blockchainSolidity Smart contract Security best practices¿Qué es Solidity en los smart contracts de Ethereum Blockchain?
View more
jeanne6663

Shopping

Tags

top 10 solidity issues

Share

Trends

trends timeline
trends timeline for Solidity%20-%20Solidity

Languages

deSolidity
enSolidity
esSolidity
fiSolidity
frSolidity
idSolidity
ruSolidity
jaSolidity

Related

Similar

JapaneseClass.jp

Travel

Japan Hotels