pirapira/bamboo

Bamboo see https://github.com/cornellblockchain/bamboo

Bamboo: a language for morphing smart contracts

Cornell Blockchain says they can now maintain the Bamboo compiler. https://github.com/CornellBlockchain/bamboo

---

Bamboo is a programming language for Ethereum contracts. Bamboo makes state transition explicit and avoids reentrance problems by default. See manifest for the motivation, or tutorial if you want to deploy something first, or semantics if you need something resembling a definition.

Example Bamboo Code

• A payment channel
• An ERC20 contract
• A vault

Compiler

The Bamboo compiler sometimes produces bytecode, which needs to be tested.

As preparation,

• install opam with OCaml 4.04.1
• opam install bamboo should install bamboo.

When you check out this repository,

bamboo < src/parse/examples/006auction_first_case.bbo

produces a bytecode. Do not trust the output as the compiler still contains bugs probably.

bamboo --abi < src/parse/examples/006auction_first_case.bbo

prints ABI.

[{"type": "constructor", "inputs":[{"name": "_beneficiary", "type": "address"},{"name": "_bidding_time", "type": "uint256"},{"name": "_highest_bid", "type": "uint256"}], "name": "auction", "outputs":[], "payable": true},{"type":"fallback","inputs": [],"outputs": [],"payable": true}]

Developing Bamboo

To try Bamboo in your local environment, run make dep from the project folder. That should install all dependencies. Once the installation process is done, run eval $(opam config env) and then you can build all targets using make, and run the tests with make test.

When you modify the OCaml source of Bamboo, you can try your version by

$ make
$ ./lib/bs/native/bamboo.native < src/parse/examples/006auction_first_case.bbo

Embark

An Embark plugin for Bamboo is available. To use it, first install Embark and add then add the plugin to your DApp.

npm install -g embark
embark new AppName
cd AppName
npm install embark-bamboo --save

then add embark-bamboo to the plugins section in embark.json:

  "plugins": {
    "embark-bamboo": {}
  }

Afterwards Embark will recognize .bbo files and compile them with Bamboo.

How to Contribute

• notice problems and point them out. create issues.
• test the bytecode like this, but using other examples. You might find bugs in the compiler.
• write new Bamboo code and test the compiler.
• join the Gitter channel.
• spread a rumor to your friends who are into programming languages.

Related Work

Linden Scripting Language

Linden Scripting Language has similar organization of code according to states.

Obsidian

Obsidian is another programming language that models smart contracts as state machines. Obsidian even tracks states of the contracts statically.

bamboo's Issues

add Travis script that compiles the OCaml files and runs `make test`.

The ordering of calldata is reversed

At commit cf55d36 , make test shows

argument x at Calldata offset 72, size 32
argument b at Calldata offset 64, size 32
argument c at Calldata offset 32, size 8
argument d at Calldata offset 0, size 32

for a source that looks like

case (int a(bytes32 x, bytes32 b, uint8 c, bytes32 d)) {

The ordering of arguments are reversed.

bamboo compiler should error out with an unknown return type of a case

contract A() {
	case (xyzxyz a(bytes32 x, bytes32 b, uint8 c, bytes32 d)) {
		return (pre_ecdsarecover(x, b, c, d)) then become A();
	}
}

should cause an error.

"Account unknown" failure during end-to-end test

In the account_unknown branch, a strange error appears

$ make end-to-end && ./end-to-end.native
ocamlbuild -use-ocamlfind -Is src/ast,src/parse,src/lib,src/codegen -package batteries -package cryptokit -package rope -package rpclib -package rpclib.unix -package unix -package rpclib.json -package ppx_deriving -package ppx_deriving_rpc -use-menhir src/exec/end-to-end.native
Finished, 91 targets (91 cached) in 00:00:00.
connected
got result 0x100000000000000000000000000000000000000000
Fatal error: exception Failure("Expected string, got '{jsonrpc:S(2.0);error:{code:I(0);data:N;message:S(Account unknown.)};id:I(0)}'")

setup_seed should not change the seed when it's already set to a non-zero value.

assertion failure in lib_test

case0 01f42fe4 0c11dedd
Fatal error: exception File "lib/lib_test.ml", line 21, characters 11-17: Assertion failed

Maybe we can use the Keccak implementation in the eth-isabelle project.

a_mem_to_str: codecopy not implemented

For example, http://dry.yoichihirai.com/?nsteps=150&contract=0x7f0000000000000000000000000000000000000000000000000000000000000000807f0000000000000000000000000000000000000000000000000000000000000040805180920190528180380382397f00000000000000000000000000000000000000000000000000000000000000025b82157f0000000000000000000000000000000000000000000000000000000000000126578181557f000000000000000000000000000000000000000000000000000000000000002090929003917f000000000000000000000000000000000000000000000000000000000000002001907f0000000000000000000000000000000000000000000000000000000000000020017f0000000000000000000000000000000000000000000000000000000000000071565b5050507f00000000000000000000000000000000000000000000000000000000000000237f0000000000000000000000000000000000000000000000000000000000000000557f0000000000000000000000000000000000000000000000000000000000000051807f000000000000000000000000000000000000000000000000000000000000004080518092019052817f00000000000000000000000000000000000000000000000000000000000001dc8239f37f000000000000000000000000000000000000000000000000000000000000000054565b7f00000000000000000000000000000000000000000000000000000000000000003560e060020a900450600256

end-to-end test should call methods with arguments sometimes

rpc_of_eth_transaction should check the format of the input (e.g. data should be an even-length hex)

Remove OCaml warnings and turn them into build errors

Implement LayoutInfo.arg_locations

Currently run_tests.sh says

Fatal error: exception Failure("LayoutInfo.arg_locations")

Implement a utility function for calling a contract's method with arguments

TODO: set up array seeds in codegen.ml

accept bytes32 as runtime arguments

add end-to-end tests in the spirit of Solidity end-to-end tests

Remove the duplication of the constructor code

The runtime code contains the constructor code of each contract, so the initialization code can just jump into it.

Implement events

Currently compiled examples do not contain events. This issue keeps track of implementing the events.

complete testing_00b

This test should witness some change in the return value of highest_bid().

bbo: add an option to emit the json ABI

./bbo.native --abi < parse/examples/00b_auction_more.bbo should return

[{"constant":false,"inputs":[],"name":"bid","outputs":[{"name":"","type":"bool"}],"payable":true,"type":"function"},{"constant":false,"inputs":[],"name":"bidding_time","outputs":[{"name":"","type":"uint256"}],"payable":true,"type":"function"},{"constant":false,"inputs":[],"name":"highest_bid","outputs":[{"name":"","type":"uint256"}],"payable":true,"type":"function"},{"inputs":[{"name":"","type":"address"},{"name":"","type":"uint256"},{"name":"","type":"uint256"}],"payable":true,"type":"constructor"},{"payable":true,"type":"fallback"}]

Maybe without payable attributes.

The runtime code should throw when it does not see the expected length of call data

Associate some byte length limit to PseudoImm.pseudo_imm

Then, an appropriate push operation can be chosen, rather than always using PUSH32.

bamboo compiler should error when it sees an unknown type name in a case argument

Parse pre_ecdsarecover(a,b,c,d)

end-to-end.native should show an easy message when it finds a wrong ethereum client

end-to-end.native command expects cpp-ethereum in --test mode. When it finds a different client, end-to-end.native should error out, saying that it expects cpp-ethereum launched in such and such way.

support calling ecrecover

test

test

Calldata alignment is wrong for arguments smaller than 32 bytes.

At commit cf55d36, make test shows

argument x at Calldata offset 72, size 32
argument b at Calldata offset 64, size 32
argument c at Calldata offset 32, size 8
argument d at Calldata offset 0, size 32

The offset and the size of argument c point to a wrong region.

Constructor code should fail if constructor arguments are not included in the init data

Currently, when constructor arguments are missing, the constructor believes that the last pieces of the code is the input. Instead, the constructor should throw when the constructor arguments are missing.

Use PUSH4 for tags

Currently PUSH32 is used for pushing jump destinations, but PUSH4 seems enough (of course the compiler should check the value being pushed fits the width).

add keccak(address, byte32) returning byte32

accept uint8 as a runtime argument.

Try to use bamboo compiler from truffle

Enable && between booleans

Accept an algebraic data type definition

reserve names starting with `pre_`

When the source contains an identifier with pre_, the compiler should error out, saying "names starting with pre_ is reserved for future use."

Syntax.size_of_typ AddressType should be 20

If we change that, some things might break, but we should do that.

highest_bid function seems to be returning a too long data

Currently, end-to-end.native shows:

got answer: 0x000000000000000000000000000000000000000000000000000000000000006400000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000

However, this should just be 0x0000000000000000000000000000000000000000000000000000000000000064.

finish implementing set_contract_arguments

Currently, sh run_tests.sh results in

Fatal error: exception Failure("set_contract_arguments")

Enable mappings to mappings

Use "with" instead of "along"

something() along value 3

something() with value 3

Remove the duplication of codegen_array_seed

decide on the syntax of calling ecrecover

• what should the head of the call look like?
• how many arguments should the call take? Variable number?

Add an ERC20 token example

accept a mapping to structs

Support returning multiple values

This example should somehow compile

contract multiret()
{
    case((uint,uint) dup(uint x)) {
        return (x,x) then multiret();
    }
}

bamboo compiler should error when it sees an unknown type in the constructor argument list

Similar to #60.

Support calling methods that return more/less than one word

Simple payment channel in bamboo

https://www.reddit.com/r/ethereum/comments/6fde8t/ethereum_payment_channels_in_50_lines_of_solidity/dihe3tj/?context=3

https://medium.com/@matthewdif/ethereum-payment-channel-in-50-lines-of-code-a94fad2704bc

This makes a great example.

syntax: return ( ) then become something();

Currently, the continuation is specified by just a then. This issue proposes then become instead of just then. This is @vkandy's idea.

./bbo.native < sketch/future.bbo should succeed

When a contract A sometimes becomes B, and B has a case called b, it should be possible to call the method b of a contract A.