Stratis Smart Contracts Documentation. Stratis Platform

Transcription

1 Stratis Platform Aug 10, 2018

2

3 Contents 1 Contents 3 i

4 ii

5 Smart contracts can now be deployed on the Stratis Full Node. Like the Full Node, Stratis smart contracts are written in C#. Smart contracts extend the functionality of a blockchain and allow it to map out complex financial interactions through the sending of funds and storage of data. However, as we shall see later in the document, the uses of smart contracts are not limited to financial interactions. The audience for this document is anyone who wants to get started writing smart contracts on the Stratis Platform. Even if you have not written a smart contract before, this is a great place to start. This material provides some basic theory about smart contracts, briefly explores some use cases, and then helps you start creating your own smart contract. An interesting example of a smart contract, based on a real-world case, is supplied to kickstart your learning. This document assumes that you are familiar with basic blockchain concepts. When it comes to writing smart contracts, a basic knowledge of C# is also assumed. However, if you are new to C# or even programming, we recommend you continue to explore Stratis smart contracts as part of your C# learning experience. More resources on the C# language are available here. A basic knowledge of Swagger and working with the command-line interface would also be useful. Note: The Stratis Smart Contract platform is currently in an open alpha stage. Things may not be stable and aspects of the development process are subject to change. Please do not use the alpha version of Stratis Smart Contracts for production applications. Contents 1

6 2 Contents

7 CHAPTER 1 Contents 1.1 Smart Contracts - Basic Theory You may already have heard of DApps (Decentralized Apps). A smart contract can also be thought of as a DApp because it is both an application and is decentralized. In fact, DApps consist of a web-based front-end that sits on top of a smart contract. A DApp is decentralized because of the properties of the smart contract; a copy of the DApp s smart contract is stored on each node in the blockchain. Smart contracts can be invoked when a transaction is added to a blockchain and, according to how they are programmed, smart contracts can redistribute the funds sent in the transaction. Note: Given a specific input, the output of the smart contract is the same no matter which node it is run on. Because of this property, smart contracts are deterministic. Smart contracts are also capable of storing (persisting) data. If they could not do this, it would be impossible for them to achieve the required level of sophistication. You might be asking a question at this point: if a smart contract is stored on every node in the blockchain but gets run on random nodes, what happens to any data it stores when running? The answer is that any data stored by a smart contract is broadcast across all nodes on the network. A smart contract on any node has up-to-date copies of its database. Note: When a new smart contract or a transaction invoking a smart contract is distributed across the network as part of a block, each node that receives the block runs the smart contract during the consensus building process. If a smart contract is found to be invalid (non-deterministic for example), the smart contract is not deployed Using.NET for smart contracts The most important aspect of the implementation of Stratis smart contracts is they use real.net, which is to say.net Core is used to execute them. The Stratis Full Node is also written in C# and the route of execution for both it 3

8 and and a Stratis smart contract is the same. Stratis smart contracts are not just using the C# syntax, they are using the full tried and tested C# package supplied by Microsoft. Because smart contracts must execute deterministically, they cannot use all capabilities of the C# language or all the.net Core libraries. The Stratis smart contracts suite includes a validation tool that checks for any non-deterministic elements in any smart contracts that you write Gas for Stratis smart contracts Smart contracts require gas to run. How much gas they need relates to how many instructions they contain. Gas is an additional expenditure to transaction fees. For example, if you send money to a smart contract, you must pay normal transaction fees and the cost in gas for any methods you call on the smart contract. Gas is separate from STRAT. Its relationship to STRAT is defined by strat = gas * gasprice. Note: As this this is an Alpha release, you will use test STRAT, which are referred to as TSTRAT during this document. 1.2 Uses of Smart Contracts This chapter contains some possible uses of smart contracts. The aim here is to inspire you to start writing your own smart contracts even if they begin life as basic versions of what might later become more sophisticated applications Financial uses of smart contracts When smart contracts are used for financial purposes, it is useful to think of them as AI wallets. Cryptocurrency can be sent to them and distributed to other users based on the logic contained within the smart contract. One example of a financial use of a smart contract is in an auction. Users can participate in the auction and make bids. The smart contract stores the bids that are made, and when the auction is over, it allows: 1. The owner of the smart contract to receive the highest bid as payment for the item. 2. Unsuccessful bidders to withdraw the bids they made. The Stratis smart contract Visual Studio Project Template contains a basic example of an auction. Later in this document, you will be given step-by-step instructions on how you can deploy and experiment with this example auction Smart contracts for voting Smart contracts can be used for voting. In this case financial transactions are substituted for votes. Once cast, the votes can be traced back to when they were cast but the identity of the voter remains secret. At the end of the election, the smart contract can publish the results. However, because the blockchain is an immutable public ledger, anyone can also go back and check the votes themselves. In addition, because the smart contract is also immutable and held on every node, its vote counting code can also be inspected by anyone Smart contracts in gaming Smart contracts can be used in the storing of statistics for tradable game entities such as a weapon or a hero. For example, they can record the history of the hero and level up the hero in respect to those achievements. The higher the 4 Chapter 1. Contents

9 level of the hero the more they can be traded for. The procedure held in the smart contract for levelling up the hero is transparent and so is the path the hero took to achieve their current level Smart contracts in delay repay schemes Smart contracts can be used in delay repay schemes. For example, they can be automatically used to handle delay repayment if a plane or train is delayed. The smart contract s owner can hold the amount paid for a ticket until a specific point in time, agreed by the customer, at which no refunds are possible. Meanwhile, the arrival times of vehicles is recorded digitally, and the smart contracts are automatically invoked with these timestamps. The smart contract checks the timestamps against the official timetables and pays compensation accordingly if any journey was late. 1.3 Deploying Your First Smart Contract This chapter takes you through deploying a smart contract, which simulates an auction. The smart contract is provided as a Visual Studio Project Template. As part of the deployment process, the smart contract is validated to ensure it does not contain any non-deterministic elements. Once deployed, a bid is then placed on the auction to test that the smart contract was deployed correctly. The steps taken when deploying the smart contract are as follows: 1. Download or clone the source. 2. Installing the Visual Studio Project Template. 3. Create a smart contracts project, which will include an auction smart contract and unit tests. 4. Validate the smart contract with the smart contract tool (SCT). 5. Run the smart contract enabled version of the full node. 6. Get the funds to deploy the auction smart contract and place a bid. 7. Build and deploy the smart contract. 8. Place a bid. 9. Check the bid has been stored on the test network. Note: This chapter assumes a Windows development environment. Stratis smart contracts can be developed on other platforms, and documentation to support this will be available soon Downloading the smart contract source First, download a copy of Microsoft Visual Studio if you don t have a copy already. This is the standard IDE for C# development and the Community Edition is available for free. Next, make sure you have the latest.net SDK installed. You can verify this by running dotnet --version on the command line. If you do not have the.net SDK installed, download and install it from here. Next, you must download or clone the latest alpha branch of the Stratis Smart Contract Enabled Full Node. This repository contains everything you need to run a Stratis full node that can sync and mine on a Stratis smart contract network. It also contains the sct tool, which validates and deploys contracts. git clone git checkout sc-alpha-latest 1.3. Deploying Your First Smart Contract 5

10 1.3.2 Installing the Visual Studio Project Template The Stratis smart contract Visual Studio Project Template provides an easy way to create a new smart contract project. It contains a template for a smart contract, unit tests, and references to appropriate NuGet packages. The template can be found on the Visual Studio marketplace Creating a smart contracts project To create a new smart contracts project, navigate to File > New > Project... and create a new Stratis SmartContract Project under Visual C#. This generates a new solution containing Auction.cs and some sample unit tests. Notice that Auction.cs just contains a C# class called Auction. Later, you will explore the individual properties and methods on this class in detail Validating your smart contract When you attempt to deploy a smart contract by including it in a transaction, it is tested to see if its C# code is correct and deterministic. Mining nodes carry out this testing before they include a smart contract transaction in a block. In addition, other nodes on the network attempt to validate any smart contracts that they find in any blocks they receive. If the smart contracts are not valid, the entire block is rejected. Therefore, you will want to know your smart contract meets the validation criteria before you try and deploy it. Stratis provides SCT (a command-line tool) for validating and building smart contracts. The SCT tool is located within the source code of the full node that was cloned earlier. Navigate to this source code directory, and then change into the SCT project directory: cd src/stratis.smartcontracts.tools.sct You are now going to validate the auction smart contract and request to see its byte code. When you begin writing your own smart contracts, you will also carry out this step for them before you deploy. Right click on your Auction.cs file tab in Visual Studio and click Copy Path. Then, back on the command line, use the validate command: dotnet run -- validate [PASTE_YOUR_PATH HERE] -sb You should see the following output: ====== Smart Contract Validation results for file [YOUR_FILE_PATH] ====== Compilation Result Compilation OK: True Format Validation Result Format Valid: True Determinism Validation Result Determinism Valid: True ByteCode 4D5A F... Congratulations! You have compiled your first smart contract in C#. The bytecode is a hexadecimal representation of the.net IL compiled for this contract and is all you need to deploy your contract on a network (provided you have a node running). To further understand why this tool is important, go back to your contract and add this line in the constructor: 6 Chapter 1. Contents

11 var test = DateTime.Now; And this line at the top of the Auction.cs file: using System; So why is the first line problematic inside a smart contract? Different nodes are going to execute the code at different times and because of this, they all receive a different result for DateTime.Now. If this value was persisted in some way, all of the nodes would receive a different outcome for the contract state and would fail to reach a consensus. Make sure you have saved Auction.cs and run the validation command again. SCT recognizes this non-deterministic call: ====== Smart Contract Validation results for file [YOUR_FILE_PATH] ====== Compilation Result Compilation OK: True Format Validation Result Format Valid: True Determinism Validation Result Determinism Valid: False.ctor: System.DateTime System.DateTime::get_Now() is non-deterministic. Now back out the non-deterministic code and resave. More about the SCT The SCT uses 3 commands: Command build deploy validate Description Builds a contract and outputs a dll. For testing purposes. Deploys a smart contract to the given node. Validates smart contracts for structure and determinism. The SCT provides further information on using these commands. For example, the following usage requests help on the validate command: dotnet run -- validate --help Running a smart contract enabled version of the Stratis full node To interact with the smart contract test network, you now need to build the smart contract daemon. This is the Stratis.StratisSmartContractsD project in the sc-alpha branch of the Stratis Smart Contract Enabled Full Node, which you either downloaded or cloned. When the project is built, run the daemon as follows: cd src/stratis.stratissmartcontractsd dotnet run -- -addnode= addnode= addnode= Adding the three nodes attempts to connect the daemon to the smart contract test network Deploying Your First Smart Contract 7

12 Note: The smart contract test network is a testing environment and its uptime may fluctuate. For the most up-to-date information on the test network status, join us on Discord: Support and Community Getting the funds to deploy smart contracts To deploy a smart contract you need funds to pay the transaction fees and the gas to run the smart contract. In this case, you are also going to test the smart contract out by placing a bid, which involves calling one of its methods. There is additional expenditure involved here because you must pay for: 1. The amount you are going to bid. 2. The transaction fees involved when making the bid (sending money to a deployed auction smart contract). 3. The gas to run the smart contract method. To get funds, you must first create a wallet and then request the funds. The next two subsections detail how to do this. Creating a wallet Because the smart contract API hasn t been integrated with any GUI wallets yet, you must use the API directly via Swagger. Whilst your node is running, navigate to To create a wallet, navigate to the Wallet section and use the /api/wallet/create call. You only need to specify a name and password in the request. For example: { } "name": "Satoshi", "password": "password" You now have a wallet containing some TSTRAT addresses. To see the addresses, use the /api/wallet/addresses call, which is also found in the Wallet section. You just need to specify your wallet name and an AccountName of account 0. Getting funds The easiest way to get some TSTRAT is use the smart contracts faucet. To receive 100 TSTRAT, specify a TSTRAT address from your wallet. Make a note of the address you use. Use this TSTRAT address for deploying and testing the smart contract. Alternatively, if you want to get more involved and earn some TSTRAT along the way, feel free to start mining! To begin mining, restart your node with an address from your wallet: dotnet run -- -addnode= addnode= addnode= mine=1 -mineaddress=[your_wallet_address] Use the TSTRAT address you use for the mine address when deploying and testing the smart contract Deploying the auction smart contract While you deploy your smart contract, it is important to remember that deploying a smart contract involves several steps: 8 Chapter 1. Contents

13 Compiling the contract. Validating the contract. Creating a transaction which contains the contract s code. Broadcasting the transaction to the network. From the command-line, you can use the deploy command to achieve all these steps: dotnet run -- deploy [PATH_TO_SMART_CONTRACT] -wallet [YOUR_ WALLET_NAME] -password [YOUR_PASSWORD] -fee sender=[your_wallet_address] - params=[constructor_params_if_required] As before, when you were validating the auction smart contract, you need to obtain the path to the Auction.cs file. However, because the Auction C# class contains a constructor parameter, durationblocks, you must pass this value as well. The durationblocks parameter specifies how many blocks are added to blockchain before the auction ends. In the following example, 20 blocks are added to the blockchain before the auction ends: dotnet run -- deploy PATH_TO_SMART_CONTRACT -wallet [YOUR_ WALLET_NAME] -password [YOUR_PASSWORD] -fee sender=[your_wallet_address] - params="10#20" A value of 20 is used because blocks are not confirmed until they are 5 blocks deep. Until the block which the smart contract is in has been confirmed, you cannot run the smart contract. You will notice that the value of 20 is preceeded by 10#. This information is part of the durationblocks constructor parameter. More information on specifying constructor parameters is given in Specifying smart contract constructor parameters. When you deploy the smart contract, you should also check the block height. To do this, find the Consensus.Height in the Node Stats of the full node output. Keep checking the block height. After Consensus.Height has incremented by 5, you can be sure the smart contract has been deployed. The tool returns the address of the contract if the contract was deployed successfully. Make sure you record this as you are going to use it when you place a bid. Specifying smart contract constructor parameters Smart contract parameters are serialized into a string. The format of each parameter is {0}#{1} where: {0} is an integer representing the Type of the serialized data and {1} is the serialized data itself. Serialized array values are separated by a dash - character. These params must be serialized into a string. The format of each parameter is {0}#{1}, where {0} is an integer representing the Type of the serialized data, and {1} is the serialized data itself. Multiple params must be specified in order and can be done like so: -param="7#abc" -param="8#123". Currently, only certain types of data can be serialized. Refer to the following table for the mapping between a type and its integer representation Deploying Your First Smart Contract 9

14 Table 1: Param Type Serialization Type Integer representing serialized Serialize to string type System.Boolean 1 System.Boolean.ToString() System.Byte 2 System.Byte.ToString() System.Byte[] 3 BitConverter.ToString() System.Char 4 System.Char.ToString() System.SByte 5 System.SByte.ToString() System.Short 6 System.Short.ToString() System.String 7 System.String System.UInt32 8 System.UInt32.ToString() NBitcoin.UInt160 9 NBitcoin.UInt160.ToString() System.UInt64 10 System.UInt64.ToString() Stratis.SmartContracts.Address 11 Stratis.SmartContracts.Address.ToString() System.Int64 12 System.Int64.ToString() Note: The requirement to pass in the Type is ugly, but it allows us to resolve overloaded methods easily. As a further example, imagine a smart contract which has a constructor with the following signature: public Token(ISmartContractState state, UInt160 owner, UInt64 supply, Byte[] secretbytes) In addition to the mandatory ISmartContractState, there are 3 parameters which need to be supplied. Assuming they have these values: UInt160 owner = 0x95D ccd9A1Fb4C813C2cb639 UInt64 supply = Byte[] secretbytes = { 0xAD, 0xBC, 0xCD } The serialized string representation of this data looks like this: The command for passing these params to sct looks like this: -param="9#0x95d ccd9a1fb4c813c2cb639" -param="10# " -param="3 #AD-BC-CD" Placing a bid on the auction smart contract You can use Swagger to place a bid on the auction smart contract you have deployed. Navigate to the SmartContracts section and use /api/smartcontracts/build-and-send-call. For example, the following usage places a bid of 10 TSTRAT. { "walletname": "[YOUR_WALLET_NAME]", "contractaddress": "[YOUR_CONTRACT_ADDRESS]", "methodname": "Bid", "amount": "10", "feeamount": "0.001", "password": "[YOUR_PASSWORD]", (continues on next page) 10 Chapter 1. Contents

15 } "sender": "[YOUR_WALLET_ADDRESS]", (continued from previous page) Once you have placed the bid, you will need to wait for the Consensus.Height to be incremented by another 5 blocks. At this point the bid transaction is confirmed. Finally, you can check the bid is stored on the test network Checking the bid has been stored on the test network Bids are persisted on each node in the network. You can use a Swagger call to check your bid has been stored on the test network. Navigate to the SmartContracts section and use /api/smartcontracts/storage. For the parameters, use the address of your deployed auction smart contract, the string HighestBid for the StorageKey, and Ulong for the DataType. A value of 10 should be returned. 1.4 The Auction Smart Contract This chapter takes a further look at the smart contract-specific parts of the Auction C# class. using Stratis.SmartContracts; public class Auction : SmartContract The first line in the contract is a reference to the Stratis.SmartContracts NuGet package. This package allows you to inherit from the SmartContract class and thereby provides subclasses with useful functionality such as sending funds, hashing, and saving data. If you are not using the Visual Studio template, you can create smart contracts just by including the Stratis.SmartContracts NuGet package in your project and inheriting from SmartContract. The only libraries that can be included in the current iteration of Stratis smart contracts are System, System.Linq and Stratis.SmartContracts. public Address Owner { get { return PersistentState.GetObject<Address>("Owner"); } private set { PersistentState.SetObject<Address>("Owner", value); } } The Auction object has several properties which are structured in a similar way to the Owner property. To persist data in a smart contract, use PersistentState. Data can be persisted anywhere in the smart contract not just inside a property. However, persisting data inside properties makes the code inside your methods easier to read. The Address class is included as part of Stratis.SmartContracts. It is an abstraction over a series of strings that enables funds to be sent to addresses. public ISmartContractMapping<ulong> ReturnBalances { get { (continues on next page) 1.4. The Auction Smart Contract 11

16 } } return PersistentState.GetMapping<ulong>("ReturnBalances"); (continued from previous page) PersistentState.GetMapping returns a dictionary-like structure for storage. Using a standard.net dictionary would require serializing and deserializing all the dictionary data every time it was updated. For dictionaries with thousands of entries (think balances of a token contract), this would require a significant amount of processing. ISmartContractMapping instead stores individual values directly into the underlying PersistentState. If you require lists of information, you also have access to ISmartContractList and PersistentState. GetList. public Auction(ISmartContractState smartcontractstate, ulong durationblocks) : base(smartcontractstate) { Owner = Message.Sender; EndBlock = Block.Number + durationblocks; HasEnded = false; } The contract constructor gets run when the contract is created for the first time. Contracts must override the base class constructor and inject ISmartContractState, which must be the first parameter of the constructor. Other parameters should be positioned after this parameter. The Message and Block objects are read-only properties on the SmartContract class which the Auction class inherits from. These properties provide access to information about the current context that a contract call is executing in. For example: block numbers, the address that called the contract, etc. Assigning a value to Owner, EndBlock, and HasEnded saves the values in PersistentState via their property setters. Setting Owner is a very common pattern when developing smart contracts and gives extra functionality to the creator of the contract. You will notice that in the AuctionEnd method, funds are sent to Owner. The Assert method, inherited from SmartContract, provides a simple way to reject contract executions that don t meet certain criteria. In this case, we re using it to reject any further execution when the message sender doesn t have a balance in our contract. The TransferFunds method, also inherited from SmartContract, enables the sending of funds to a specific address. This will send funds to ordinary addresses or contracts. A third parameter can be specified as input for this method to give more information about the method etc. to call on a contract. public bool Withdraw() { ulong amount = ReturnBalances[Message.Sender]; Assert(amount > 0); ReturnBalances[Message.Sender] = 0; ITransferResult transferresult = TransferFunds(Message.Sender, amount); if (!transferresult.success) ReturnBalances[Message.Sender] = amount; return transferresult.success; } There are a few more methods in the Auction class, but the final method to look at is Withdraw. This method checks whether the caller has a balance to withdraw from. If they do, this balance will be deducted from the smart contract state and they will be sent the funds. Note: You may be wondering why there is a Withdraw method at all. Why not just transfer the funds to their owner as soon as they become available? The reason is because the owner of these funds could be another smart contract that 12 Chapter 1. Contents

17 cannot be controlled. Sending the funds back to such a contract would potentially call unknown code using another user s funds. Therefore, the Withdraw pattern is very common in smart contracts. If users call a contract, that contract execution should never execute an untrusted smart contract s code. 1.5 Testing Stratis Smart Contracts are unit-testable in the same way as any other C# class. Unit tests can be written with the testing framework of your choice. Tests can be developed and debugged with Visual Studio s step-through debugger. Note: While contracts are fully testable, the available testing utilities are still primitive. Future versions of smart contracts will enable testing on top of a local test blockchain with resource tracking code injected The Basics The smart contract Visual Studio Project Template, which contains the Auction smart contract, also contains tests for this contract. The tests described here verify that your smart contract logic executes as intended before you deploy it to a live network. The tests inside the template use the Microsoft.VisualStudio.TestTools.UnitTesting library, which may be familiar to C# developers: [TestClass] defines a class in which tests are defined. [TestInitialize] is used to mark a method to be run before tests execute, most commonly to set up some testing context. [TestMethod] marks the actual tests to be run. The static class Assert provides access to a range of methods to validate the results of whatever execution you perform inside your tests. To run the tests together, right click on [TestClass] and select Run Tests in Visual Studio. To run tests individually, right click on the individual method and select Run Tests. Once clicked, the solution will take a couple of seconds to build and then the Test Explorer will open. You should see your tests listed next to a green tick, which indicates the tests have passed. You can also debug contract execution in Visual Studio. If breakpoints are set in the Auction smart contract methods and you then right click and select Debug Tests on the test methods, you will reach any breakpoints set in the methods being tested. You can then inspect the current state of the contract and step through execution as with any other C# application State Injection A Stratis smart contract s constructor has a single mandatory parameter: public ExampleContract(ISmartContractState state). Contextual blockchain state is injected into this parameter at contract execution time. Because state is abstracted behind the ISmartContractState interface, it allows any possible state of the blockchain to be mocked and injected while unit testing is being carried out. The ISmartContractState interface contains these members: IBlock Block - Contains information about the block in which the smart contract transaction has been included. IMessage Message - Contains information about the contract invocation environment. IPersistentState PersistentState - Represents the persistent storage available to a contract Testing 13

18 IGasMeter GasMeter - Represents an object used to measure the amount of gas consumed during contract execution. IInternalTransactionExecutor InternalTransactionExecutor - Represents an executor used to process transactions generated from within the contract. IInternalHashHelper InternalHashHelper - Provides hashing functions to the contract. Func<ulong> GetBalance - A function which provides the current balance of the contract. A unit test can define its own representations of these interfaces and then inject them into the contract under test An Example Stepping through the TestBidding() method from the template should help you understand the basic approach to unit testing your contracts with a mock contract state. var auction = new Auction(SmartContractState, Duration); The first step to testing your contracts is initialising them. A TestSmartContractState object is injected into the Auction object. This TestSmartContractState object is an implementation of the same ISmartContractState interface that is injected when smart contracts are initialised on-chain. The only difference is that in this case all of the properties can be set by you. This is really useful if you want to explicitly target scenarios in your contract s execution. Assert.IsNull(SmartContractState.PersistentState.GetObject<Address>("HighestBidder"). Value); Assert.AreEqual(0uL, SmartContractState.PersistentState.GetObject<ulong>("HighestBid ")); These calls check that the world state is as expected after contract instantiation. In other words, they check that no highest bidder has yet been set and that the current highest bidder is set to 0, which is exactly what the constructor is set to do. ((TestMessage)SmartContractState.Message).Value = 100; auction.bid(); The first line here is an example of setting the state to represent exact scenarios that you wish to test. 1.6 Support and Community If you re having issues with any part of the process, want to provide us with any feedback, or just want to drop by and show us something cool you made, join us in the #smartcontracts room on Discord Report a Bug You can also raise any issues you have along the way in the Stratis Full Node github repository. Please apply the smart-contracts label to any issues that are specific to smart contracts. For anything urgent, feel free to contact us in the #smartcontracts channel in Discord. 14 Chapter 1. Contents

19 1.7 Appendix - Future Enhancements to Stratis Smart Contracts We are committed to continually improving Stratis smart contracts. Future enhancements include: Optimizing compiler output to reduce the size of contracts stored on-chain. Improvements to the validation output. For example, plans exist to show the line where non-deterministic code has been detected. Further integration with Microsoft Visual Studio so live feedback is provided during coding. This will identify potential bugs, non-deterministic code, and also suggest improvements for the smart contract. Support for event and logs to facilitate communication between smart contracts and their user interfaces. Support for a web3-like front-end library to facilitate communication between smart contracts and web applications. Improvements to the testing utilities. This includes the ability to auto-generate a blockchain state and the ability to measure the gas required for a smart contract method call. Standard interfaces for common smart contracts. This includes an ERC20-type token interface. Native F# support. A self-destruct functionality for smart contracts. NuGet distribution for common smart contract libraries. 1.8 Appendix - Gas Prices Smart contract execution costs the gas price (in satoshis) multiplied by the gas used. The gas price and the maximum amount of gas to be used are set at the transaction level. Gas Price: Minimum: 1. Maximum: Gas Limit: Minimum: Maximum: For most transactions, we would recommend setting your gas price to 1 and the gas limit to Note: The gas costs below are subject to change but we expect that the total cost for interacting with or creating smart contracts should not exceed ~$5 USD. Table 2: Gas Costs Operation Cost Description Base Cost 1000 The cost for executing any smart contract transaction. Contract Creation 1000 The cost for creating a new smart contract. Cost Instruction Cost 1 The cost for executing each CIL instruction. System Method 5 The cost for calling any system method. Call Cost Storage Cost 10 The cost for storing 1 byte via PersistentState. This currently includes (byte) both keys and values every time a value is set Appendix - Future Enhancements to Stratis Smart Contracts 15

20 Note: Base cost and contract creation cost are affected by changes in the gas price too. For example, if the gas price is set to 2, the base cost and contract creation cost rise to System method calls always remain free. 16 Chapter 1. Contents