Json-RPC behaves incorrecly and testnet setup

JamesD · April 29, 2022, 9:24pm

I have a couple questions regarding the JSON-RPC and command line tools (I highlighted my concrete questions using bold markup).

derohe Release66

Why is it that my daemon (connected to a miner) in testnet only mines miniblocks at one topoheight endlessly? When restarting the miner and the daemon it instantly mines at the next height.
This makes it impossible for me to register new accounts needed to test smart contracts.
Is that a temporary issue or am I doing something wrong here?

derohe Release62

On this version registering new accounts works fine, but the daemon JSON-RPC handles getsc requests incorrectly (I guess):

I am using the stargate RPC documentation, please correct me if that is not the right API.

When requesting multiple keys using the "keysstring" parameter, the response always only contains the value of the last key requested.
Eg. request body:

{
	"id": "1",
	"method": "getsc",
	"jsonrpc": "2.0",
	"params": {
		"scid": "my_scid",
		"variables": false,
		"code": false,
		"keysstring": ["key_1", "key_2"]
	}
}

response:

{
  "jsonrpc": "2.0",
  "id": "1",
  "result": {
    "valuesstring": [
      "value_of_key_2"
    ],
    "balance": 0,
    "code": "",
    "status": "OK"
  }
}

In the source code it uses Golang’s append() function, so this should not happen, eh???

Sadly, this makes the JSON-RPC unusable to efficiently obtain smart contract variables.

Should I file an issue for that over on github?

I am aware that I could obtain all the key-value pairs using the parameter "variables": true, but that seems to be highly inefficient because my use case is fetching few keys often.

If this method is not inefficient because of some graviton-magic, please let me know and I’ll base my project on that.

apparent smart contract size limit

I could not find any information on whether there actually is a size limit for smart contracts (in testnet).
I have a smart contract that is ca. 19.17kb.
I ensured that it is correct and parseable. However, when adding an arbitrary (correct) line, it won’t be accepted by the daemon. The code can be seen using the explorer (SC Arguments: [...]). The explorer does not show any values, neither does it list the code in a structured way. The smart contract does not contain any values (Initialize() is not called) and cannot be invoked.

All this does not happen when staying below ca. 19.17kb smart contract size.
I have enough unlocked funds in my testnet wallet.

What is my problem here and is there a limit to a smart contract’s size?

I hope this is the right place to ask for help.
If it is not, please direct me to the correct place.
I can still only use 2 links in this post, feel free to ask for clarifications.

nelbert442 · May 3, 2022, 1:14am

Regarding your first version questions, please use version 73 (just recently released) for testing. You should also be seeing now an error message in the daemon if you’re running a private testnet and no additional peers:

RROR   we want to broadcast block, but donot have peers, most possibly block will go stale

github.com

deroproject/derohe/blob/607af6dfdc9a5c6b952f987f18adf532ad383ce7/p2p/connection_pool.go#L417

      
        
            		return connections[i].Latency < connections[j].Latency
            	})
            
            
	bw_factor, _ := strconv.Atoi(os.Getenv("BW_FACTOR"))
            	if bw_factor < 1 {
            		bw_factor = 1
            	}
            
            
	for { // we must send all blocks atleast once, once we are done, break ut
            
            
		if len(connections) < 1 {
            			globals.Logger.Error(nil, "we want to broadcast block, but donot have peers, most possibly block will go stale")
            			return
            		}
            		for _, v := range connections {
            			select {
            			case <-Exit_Event:
            				return
            			default:
            			}
            			if atomic.LoadUint32(&v.State) != HANDSHAKE_PENDING && PeerID != v.Peer_ID && v.Peer_ID != GetPeerID() { // skip pre-handshake connections

In previous version 66, it was observed similar to your description but adding 1 or more peers modified the results and allowed it to work as expected.

nelbert442 · May 3, 2022, 1:15am

regarding your get_sc call, try this, again, in version 73. I cannot seem to replicate your issues as I’m getting back the correct values however please check again to be certain.

nelbert442 · May 3, 2022, 1:34am

regarding the SC size, 20kb limit:

Config max limit:

github.com

deroproject/derohe/blob/main/config/config.go#L44

      
        
            const MINIBLOCK_HIGHDIFF = 9
            
            
// note we are keeping the tree name small for disk savings, since they will be stored n times (atleast or archival nodes)
            // this is used by graviton
            const BALANCE_TREE = "B" // keeps main balance
            const SC_META = "M"      // keeps all SCs balance, their state, their OWNER, their data tree top hash is stored here
            // one are open SCs, which provide i/o privacy
            // one are private SCs which are truly private, in which no one has visibility of io or functionality
            
            
// this limits the contract size or amount of data it can store per interaction
            const MAX_STORAGE_GAS_ATOMIC_UNITS = 20000
            
            
// Minimum FEE calculation constants are here
            const FEE_PER_KB = uint64(20) // .00020 dero per kb
            
            
// we can easily improve TPS by changing few parameters in this file
            // the resources compute/network may not be easy for the developing countries
            // we need to trade of TPS  as per community
            const STARGATE_HE_MAX_BLOCK_SIZE = uint64((10 * 1024 * 1024) + (256 * 1024)) // max block size limit
            
            
const STARGATE_HE_MAX_TX_SIZE = 300 * 1024 // max size

Set max storage limit:

github.com

deroproject/derohe/blob/main/dvm/sc.go#L243

      
        
            			err = fmt.Errorf("entrypoint '%s' parameter type missing or not yet supported (%+v)", entrypoint, p)
            			return
            		}
            	}
            
            
	state.GasComputeLimit = int64(10000000) // everyone has fixed amount of compute gas
            	if state.GasComputeLimit > 0 {
            		state.GasComputeCheck = true
            	}
            
            
	// gas consumed in parameters to avoid tx bloats
            	if gasstorage_incoming > 0 {
            		if gasstorage_incoming > config.MAX_STORAGE_GAS_ATOMIC_UNITS {
            			gasstorage_incoming = config.MAX_STORAGE_GAS_ATOMIC_UNITS // whatever gas may be provided, upper limit of gas is this
            		}
            
            
		state.GasStoreLimit = int64(gasstorage_incoming)
            		state.GasStoreCheck = true
            	}
            
            
	// deduct gas from whatever has been included in TX

Error / fail out if reached:

github.com

deroproject/derohe/blob/main/dvm/dvm.go#L452

      
        
            		if state.GasComputeCheck && state.GasComputeUsed > state.GasComputeLimit {
            			panic("Insufficient Gas")
            		}
            	}
            }
            
            
// consume and check storage gas
            func (state *Shared_State) ConsumeStorageGas(c int64) {
            	if state != nil {
            		state.GasStoreUsed += c
            		if state.GasStoreCheck && state.GasStoreUsed > state.GasStoreLimit {
            			panic("Insufficient Storage Gas")
            		}
            	}
            }
            
            
type DVM_Interpreter struct {
            	Version     semver.Version // current version set by setversion
            	SCID        string
            	SC          *SmartContract
            	EntryPoint  string