Smart contracts runtime

[liamzebedee]

• [ ] ERC20 / BFK20 interface and token standard
• [ ] DEX (FUCKSWAP)
• [ ] Smart contract runtime / state model

Smart contract runtime model

Approaches:

• Bitcoin: no smart contracts. Simple Forth interpreter VM, with instructions like CHECKSIGVERIFY and MUL.
• Ethereum: full smart contracts. Messages (from, to, data, value), implicit contract creation (when data is non-null, this is contract bytecode), explicit contract creation via EVM opcodes CREATE/CREATE2, CALL opcode to call contracts, each contract has its own area of persistent memory aka storage, calling functions via the EVM ABI interface - ie. CALL with 6 arguments, push ABI-coded "function selector" onto stack and then binary search at the callsite inside contract bytecode
• Starkware/Cairo OS: Cairo OS is written in Cairo itself.
• x86/C - x86 assembly. We compile our programs to a binary (a.out, a.exe), then execute them through the OS which loads them into CPU, begins executing opcode by opcode. Then to read/write files, call other programs, we invoke a syscall via the interrupt opcode 80h/0x80 and pass some arguments according to the unistd.h interface on Linux https://en.wikipedia.org/wiki/System_call

Someone implemented a syscall interrupt opcode in brainfuck - https://github.com/ajyoon/systemf

[liamzebedee]

https://github.com/ajyoon/systemf/tree/master/examples/http

https://github.com/mzattera/FuckBench/tree/master

https://github.com/bf-enterprise-solutions/os.bf !!!

https://github.com/bf-enterprise-solutions

https://github.com/bf-enterprise-solutions/bfosix

[liamzebedee]

JESUS FUCKING CHRIST

https://github.com/f-prime/arcanevm

[liamzebedee]

This is from the Cairo whitepaper:

I like the idea of memory-mapped IO. Instead of defining a new brainfuck opcode for a "syscall interrupt", it should be possible to hook the builtin I/O operators of Brainfuck (. and ,) and build a simple IO interface.

Here's how it could work. All we want is a contract runtime. What does that entail? Programs, with persistent storage, that is permissioned only to them, and the ability to call programs within other programs.