DERO-HE Quickstart

Homomorphic encryption is a form of encryption allowing one to perform calculations on encrypted data without decrypting it first. The result of the computation is in an encrypted form, when decrypted the output is the same as if the operations had been performed on the unencrypted data.

Homomorphic encryption can be used for privacy-preserving outsourced storage and computation. This allows data to be encrypted and out-sourced to commercial cloud environments for processing, all while encrypted. In highly regulated industries, such as health care, homomorphic encryption can be used to enable new services by removing privacy barriers inhibiting data sharing. For example, predictive analytics in health care can be hard to apply via a third party service provider due to medical data privacy concerns, but if the predictive analytics service provider can operate on encrypted data instead, these privacy concerns are diminished.

DERO is pleased to announce release of DERO Homomorphic Encryption Protocol testnet. DERO will migrate from exisiting CryptoNote Protocol to it’s own DERO Homomorphic Encryption Blockchain Protocol(DHEBP).

Documentation

DVM is a decentralized platform that runs both public and private smart contracts: applications that run exactly as programmed without any possibility of downtime, censorship, fraud or third-party interference.Public Smart contracts are open versions. However, the DVM is being designed to support Private Smart Contracts where everything is hidden, eg parties, and information involved. Smart Contracts are nothing but rules which apply on transacting parties.

Current version of DVM is an interpretor based system to avoid security vulneribilities, issues and compiler backdoors. This also allows easy audits of Smart Contracts for quality,bug-testing and security assurances. DVM supports a new language DVM-BASIC.

DVM apps run on a from scratch custom built privacy supporting, encrypted blockchain, an enormously powerful shared global infrastructure that can move value around and represent the ownership of assets/property without leaking any information.No one knows who owns what and who transferred to whom.

  • This enables developers to create puzzles, games, voting, markets, store registries of debts or promises, move funds in accordance with instructions given long in the past (like a will or a futures contract) and many other ideas/things that have not been invented yet, all without a middleman or counterparty risk.

  • DVM-BASIC is a contract-oriented, high-level language for implementing smart contracts. It is influenced by GW-BASIC, Visual Basic and C and is designed to target the DERO Virtual Machine (DVM). It is very easy to program and very readable.

  • DVM runs Smart Contracts which are a collection of functions written in DVM-BASIC. These functions can be invoked over the blockchain to do something. SCs can act as libraries for other SCs.

  • DVM supports number of comments formats such as ‘, // , /* */ as good documentation is necessary.

Example Factorial Program

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
             ' This is a comment
             // This comment is supported
             /* this is multi-line comment  */
              Function Factorial(s Uint64) Uint64   // this is a commment
                     10  DIM result,scopy as Uint64     /* this is also comment */
                     15  LET scopy =  s
                     20  LET result = 1
                     30  LET result = result * s
                     40  LET s = s - 1
                     50  IF s >= 2 THEN GOTO 30
                     60  PRINTF "FACTORIAL of %d = %d" scopy result
                     70  RETURN result
             End Function

DVM are written in a DVM-BASIC custom BASIC style language with line numbers.

DVM supports uint64 and string data-types.

DVM interprets the smart-contract and processes the SC line-line

  • uint64 supports almost all operators namely +,-,*,/,%

  • uint64 support following bitwise operators & ,|, ^, ! , >> , <<

  • uint64 supports following logical operators >, >= , <, <=, == , !=

  • string supports only + operator. string support concatenation with a uint64.

  • string supports ==, != logical operators.

  • All DVM variables are mandatory to define and are initialized to default values namely 0 and “”.

A SC execution must return 0 to persist any changes made during execution. During execution, no panics should occur.

DIM Statement

DIM stands for data in memory and is used to define variable names within a function

syntax

10 DIM variable1 as type 20 DIM variable1,variable2 as type

type can be any type supported by DVM

Defining a varible initializes a variable to its ZERO value.

Function statement

Function statement is used to define a function. See eg, below for a function which adds 2 numbers

1
2
3
             Function ADD(x uint64, y uint64) uint64
             10 RETURN x + y
             End Function

Function syntax is of 2 types

  1. Function function_name( 0 or more arguments )

  2. Function function_name( 0 or more arguments ) return type

The rules for functions are as follows

  • All functions begin with Function keyword

  • Function name should be alpha-numeric. If the first letter of the function is Upper case alphabet, it can be invoked by blockchain and other smart-contracts. Otherwise the function can only be called by other functions within the smart contract.

  • Function may or may not have a return type

  • All functions must use RETURN to return from function or to return a value. RETURN is mandatory.

  • All functions must end with End Function. End Function is mandatory

  • A function can have a implicit parameter value of type uint64, which contains amount of DERO value sent with the transaction.

Any error caused during processing will immediately stop execution and discard all changes that occur during SC execution.

Any Entrypoint which returns uint64 value 0 is termed as success and will make transaction to commit all state changes.

GOTO Statement

It is used to jump to any point within the function. It cannot cross function-boundary

syntax GOTO line-number

IF

If statement is used to evaluate expression and make decisions.It has following forms

  1. IF expr1 condition expr2 THEN GOTO line number

  2. IF expr1 condition expr2 THEN GOTO line number ELSE GOTO line number

This is used to change execution flow based on conditions. Conditions can be as complex expressions

LET Statement

LET is used to assign a value to a variable. value can be as complex as possible and can contain complex expression

syntax

line number LET variable_name = expression;

expression can invoke other functions,eg

10 LET x = 2 + 3 + ADD(2,3)

ANY assignments within DVM can only be done using LET

Lottery.bas

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
             /* Lotter Smart Contract in DVM-BASIC
This lottery smart contract  will give lottery wins every  xth try.
     */

     Function Lottery(value Uint64) Uint64
     10  dim deposit_count,winner as Uint64
     20  LET deposit_count =  LOAD("deposit_count")+1
     25  IF value == 0 THEN GOTO 110  // if deposit amount is 0, simply return
     30  STORE("depositor_address" + (deposit_count-1), SIGNER()) // store address for later on payment
     40  STORE("deposit_total", LOAD("deposit_total") + value )
     50  STORE("deposit_count",deposit_count)
     60  IF LOAD("lotteryeveryXdeposit") > deposit_count THEN GOTO 110 // we will wait till X players join in
       // we are here means all players have joined in, roll the DICE,
     70  LET winner  = RANDOM() % deposit_count // we have a winner
     80  SEND_DERO_TO_ADDRESS(LOAD("depositor_address" + winner) , LOAD("lotterygiveback")*LOAD("deposit_total")/10000)
         // re initialize for another round
     90   STORE("deposit_count", 0)   //  initial players
     100  STORE("deposit_total", 0)   //  total deposit of all players
     110  RETURN 0
     End Function

     // this function is used to initialize parameters during install time
     Function Initialize() Uint64
     10  STORE("owner", SIGNER())   // store in DB  ["owner"] = address
     20  STORE("lotteryeveryXdeposit", 2)   // lottery will reward every X deposits

             // how much will lottery giveback in 1/10000 parts, granularity .01 %
     30  STORE("lotterygiveback", 9900)   // lottery will give reward 99% of deposits, 1 % is accumulated for owner to withdraw
     33  STORE("deposit_count", 0)   //  initial players
     34  STORE("deposit_total", 0)   //  total deposit of all players
     35 printf "Initialize executed"
     40 RETURN 0
     End Function

     // used to tune lottery parameters
     Function TuneLotteryParameters(input Uint64, lotteryeveryXdeposit Uint64, lotterygiveback Uint64) Uint64
     10  dim key,stored_owner as String
     20  dim value_uint64 as Uint64
     30  IF ADDRESS_RAW(LOAD("owner")) == ADDRESS_RAW(SIGNER()) THEN GOTO 100  // check whether owner is real owner
     40  RETURN 1

     100  STORE("lotteryeveryXdeposit", lotteryeveryXdeposit)   // lottery will reward every X deposits
     130  STORE("lotterygiveback", value_uint64)   // how much will lottery giveback in 1/10000 parts, granularity .01 %
     140  RETURN 0 // return success
     End Function

     // this function is used to change owner
     // owner is an string form of address
     Function TransferOwnership(newowner String) Uint64
     10  IF ADDRESS_RAW(LOAD("owner")) == ADDRESS_RAW(SIGNER()) THEN GOTO 30
     20  RETURN 1
     30  STORE("tmpowner",newowner)
     40  RETURN 0
     End Function

     // until the new owner claims ownership, existing owner remains owner
     Function ClaimOwnership() Uint64
     10  IF ADDRESS_RAW(LOAD("tmpowner")) == ADDRESS_RAW(SIGNER()) THEN GOTO 30
     20  RETURN 1
     30  STORE("owner",SIGNER()) // ownership claim successful
     40  RETURN 0
     End Function

     // if signer is owner, withdraw any requested funds
     // if everthing is okay, thety will be showing in signers wallet
     Function Withdraw( amount Uint64) Uint64
     10  IF ADDRESS_RAW(LOAD("owner")) == ADDRESS_RAW(SIGNER()) THEN GOTO 30
     20  RETURN 1
     30  SEND_DERO_TO_ADDRESS(SIGNER(),amount)
     40  RETURN 0
     End Function

Lotter SC Guide

Dero Stargate DVM Smart Contracts guide to install and test various function of lottery Smart Contract.

Download Dero Stargate testnet source and binaries.

./derod-linux-amd64  --testnet;

Start DERO wallet in testnet.

dero-wallet-cli-linux-amd64 --rpc-server --wallet-file testnet.wallet --testnet;

Start Dero wallet second instance to test transfer/ownership functions etc.

dero-wallet-cli-linux-amd64 --wallet-file testnet2.wallet --testnet --rpc-server --rpc-bind=127.0.0.1:30308;

Dero testnet Explorer

./explorer-linux-amd64  --rpc-server-address 127.0.0.1:30306 --http-address=0.0.0.0:8080;

DERO Stargate Testnet Explorer

https://testnetexplorer.dero.io/

Installing Smart Contract

Download Lottery.bas

curl  --request POST --data-binary   @lottery.bas http://127.0.0.1:30309/install_sc;

Examples of various lottery Smart Contract functions Eg: To play lottery

curl -X POST http://127.0.0.1:30309/json_rpc -H 'Content-Type: application/json' -d '{"jsonrpc":"2.0","id":"0","method":"transfer_split","params":{"mixin":5,"get_tx_key": true , "sc_tx":{"entrypoint":"Lottery","scid":"ab82caa18753efa0f76e7266af7fdd7f11e0ada5e135bd63f1cd823f5e2c2fdc" , "value":4000000000000 } }}';

Eg: Withdraw balance

curl -X POST http://127.0.0.1:30309/json_rpc -H 'Content-Type: application/json' -d '{"jsonrpc":"2.0","id":"0","method":"transfer_split","params":{"mixin":5,"get_tx_key": true , "sc_tx":{"entrypoint":"Withdraw","scid":"55aaf55b5203cd10f473a9bcf641f305885235e176270ae5e38ba6fa05dbf2b0", "params":{ "amount":"1" } } }}';

Eg: To transfer ownership

curl -X POST http://127.0.0.1:30309/json_rpc -H 'Content-Type: application/json' -d '{"jsonrpc":"2.0","id":"0","method":"transfer_split","params":{"mixin":5,"get_tx_key": true , "sc_tx":{"entrypoint":"TransferOwnership","scid":"55aaf55b5203cd10f473a9bcf641f305885235e176270ae5e38ba6fa05dbf2b0", "params":{ "newowner":"dETohFmTunwF58wAs5Jn3d1N1oaJqwRxvarNJudUh95nVbZyigTja1W8Ljzp3j8VhxbB9gv3TBs4W5gnFa24cehz2cM6nUg84s" } } }}';

Eg: To claim ownership

curl -X POST http://127.0.0.1:30308/json_rpc -H 'Content-Type: application/json' -d '{"jsonrpc":"2.0","id":"0","method":"transfer_split","params":{"mixin":;

Return Statement

It is used to return from a function and can be used anywhere within a function

syntax

  1. RETURN ( return nil )

  2. RETURN expression ( evaluates expression and returns value )

any return value must match with the type defined while declaring function

Support Functions

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
             Support Functions are inbuilt functions which provide some functionality or expose internals for speed and technical reasons.


             LOAD(variable)
             ==============

             LOAD loads a variable which was previously stored in the blockchain using STORE function. Return type will be Uint64/String depending on what is stored.
             It will panic  if the value does NOT exists

             Uint64 EXISTS(variable)
             =======================
             EXISTS return 1 if the variable is store in DB and 0 otherwise

             STORE(key variable, value variable)
             ===================================
             STORE stores key and value in the DB. All storage state of the SC is accessible only from the  SC which created it.

             Uint64 RANDOM()
             Uint64 RANDOM(limit Uin64)
             ============================
             RANDOM returns a random using a PRNG seeded on BLID,SCID,TXID. First form gives a uint64, second form returns
             random number in the range 0 - (limit),  0 is inclusive, limit is exclusive

             String SCID()
             ==============
             Returns SMART CONTRACT ID which is currently running

             String BLID()
             ==============
             Returns current BLOCK ID which contains current execution-in-progress TXID

             String TXID()
             =============
             Returns current TXID which is execution-in-progress.

             Uint64 BLOCK_HEIGHT()
             =====================
             Returns current chain height of BLID()

             Uint64  BLOCK_TOPOHEIGHT()
             ===========================
             Returns current topoheight of BLID()

             String SIGNER()
             =================
             Returns address of who signed this transaction

             Uint64 IS_ADDRESS_VALID(p String)
             =================================
             Returns 1 is address is valid, 0 otherwise


             String ADDRESS_RAW(p String)
             ============================
             Returns address in RAW form as 64 byte keys, stripping away textual/presentation form. 2 address should always be compared in  RAW form

             SEND_DERO_TO_ADDRESS(a String, amount Uint64)
             ==============================================
             Sends amount DERO  from SC DERO balance to a address. address must in string form DERO/DETO form
             If the SC does not have enough balance, it will panic