On-chain user scripts ("dumb" contracts)

[clockworkgr]

THIS IS FOR VERY PRELIMINARY DISCUSSION ONLY

As a user I want the ability to install scripts on-chain (let's call them "dumb" contracts) so that I can automate sequences of operations on-chain.

Additional Context (optional)

Ideally we would have the ability to write small scripts (turing-completeness not necessary) that leverage conditionals, loops (bounded) the ability to store (a limited amount of) data on-chain and call BitShares platform ops.

Scripts would be installed as sub-accounts under the account creating them and accessed with a sort of name-spacing mechanism for user-friendliness (e.g. account name: clockwork::dividend-script)

Scripts can have different entry points depending on the operation that impacts them to allow for complete functionalities and better performance while we also allow owner accounts to explicitly call methods on them via a new op i.e. call_script_method(script_account,method_name,[params]).

e.g. in pseudocode

script some_simple_script {   
     
     init() {
         // state loaded, common housekeeping when ran
     }

     chain_callable function onTransferIn(from, amount,asset) {
        // do stuff when a transfer comes in
     }
     
     user_callable function setSomeData(data) {
        // update state based on owner input
     }

    etc...
}

The main issue I see here is that the block-producing nodes don't have access to the full database which severely limits functionality. E.g. I can't query the list of holders of a certain asset inside a script for example.

Still there are use cases I can see this kind of functionality being helpful.

CORE TEAM TASK LIST

• Evaluate / Prioritize Feature Request
• Refine User Stories / Requirements
• Define Test Cases
• Design / Develop Solution
• Perform QA/Testing
• Update Documentation

[cogutvalera]

Nice !

[xeroc]

Maybe we should distinguish

• stateful, from
• stateless contracts.

A stateless contract just consists of an instruction set with certain inputs. Think sharedrop or dividends. Those are automated transfers to multiple/all accounts. No state is required, all incoming tokens are distributed. Another example is Bitcoin's Script.

A stateful contract, in contrast, is much more difficult I think. Mostly because the block producers would need to validate state consistently as well. I would argue that this is out of scope for BitShares.

[cogutvalera]

NOTE INFO

1. https://github.com/HcashOrg/HyperExchange they support smart contract
2. https://github.com/gxchain/gxb-core GXChain supports not only smart contract, blockchain as a service (BaaS) but also provides many unique services, including ID verification, multi-dimensional data, KYC, and swift login

[oxarbitrage]

I did some brief research a while ago looking into the possibilities of supporting some scripting language inside the core. I think the solution could be done in the form of a plugin and do not modify the core logic at all unless really needed.

Plugin should expose an API to upload script file and plugin will process it. On my research i found that LUA plays nice with c++ and it seems easy to get started and build some sort of prototype. LUA is MIT(https://www.lua.org/license.html), LUA was(maybe still is) used in some well known trading platforms like Trade Station among other reasons i don't remember now, LUA was the best candidate of that moment IMHO.
An embedded scripting language will avoid us to parse all the statements a scripting language should need to make something useful, no need to reinvent the wheel there.

I can do some more research on this now that it is posted here. Whatever path we follow, effort to make this well will be huge as a lot of details need to be considered but as an optional plugin it haves more possibilities to be done and adopted and scaled.