Truffle 5

.vscode/launch.json

@@ -0,0 +1,17 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "type": "node",
+            "request": "launch",
+            "name": "Launch Program",
+            "useWSL": true,
+            "preLaunchTask": "ganache",
+            "args": ["test"],
+            "program": "${workspaceFolder}/node_modules/.bin/truffle"
+        }
+    ]
+}

.vscode/tasks.json

@@ -0,0 +1,19 @@
+{
+    // See https://go.microsoft.com/fwlink/?LinkId=733558 
+    // for the documentation about the tasks.json format
+    "version": "2.0.0",
+    "tasks": [
+        {
+            "label": "ganache",
+            "isBackground": true,
+            "type": "npm",
+            "options": {
+                "shell": {
+                    "args": ["-i", "-c"]
+                }
+            },
+            "script": "ganache",
+            "problemMatcher": []
+        },
+    ]
+}

README.md

@@ -7,11 +7,10 @@ The whitepaper for BeakerOS is contained in a separate repository:
 
 ## Installation
 
-You will need Nodejs and Yarn Installed.
+You will need Nodejs Installed.
 
-* Get yarn: `npm -g i yarn`
-* Install: `yarn`
+* Install: `npm i`
 
 ## Testing
 
-Run `yarn test`.
+Run `npm test`.

beakerlib/index.js

@@ -122,7 +122,7 @@ class CallCap extends Cap {
     // Format the capability values into the values that will be stored in the
     // kernel. Must be defined for all subclasses
     keyValues() {
-        const val = Array.from(this.keys.map(x=>web3.fromAscii(x.padEnd(32,'\0'))));
+        const val = this.keys.map(x=> web3.utils.utf8ToHex(x).padEnd(66,'0'))
         return val;
     }
 }
@@ -138,7 +138,7 @@ class RegisterCap extends Cap {
     // Format the capability values into the values that will be stored in the
     // kernel. Must be defined for all subclasses
     keyValues() {
-        const val = Array.from(this.keys.map(x=>web3.fromAscii(x.padEnd(32,'\0'))));
+        const val = this.keys.map(x=> web3.utils.utf8ToHex(x.padEnd(32,'\0')))
         return val;
     }
 }

contracts/Kernel.sol

@@ -408,7 +408,8 @@ contract Kernel is Factory {
                     }
                 } else {
                     assembly {
-                        // Revert with an error code
+                        // Revert with an error code due to an incorrect number
+                        // of topics
                         mstore(0,44)
                         revert(0,0x20)
                     }

contracts/test/valid/SysCallTest.sol

@@ -1,26 +1,58 @@
 pragma solidity ^0.4.17;
 
-import "../../BeakerContract.sol";
-
-contract SysCallTest is BeakerContract {
+contract SysCallTest {
     function S() public {
-        uint256 n = read(0x8000);
-        write(0x8000,n+1);
         assembly {
-            if iszero(eq(sload(0x8000),add(n,1))) {
-                mstore(0xd,2200)
+            // First get the original value from storage
+            let orig_value := sload(0x8000)
+            // First set up the input data (at memory location 0x0)
+            // The write call is 0x-07
+            mstore(0x0,0x07)
+            // The capability index is 0x-01
+            mstore(0x20,0x01)
+            // The storage location we want is 0x8000
+            mstore(0x40,0x8000)
+            // The value we want to store
+            mstore(0x60,add(orig_value,1))
+            // clear the output buffer
+            mstore(0x80,0)
+            // "in_offset" is at 31, because we only want the last byte of type
+            // "in_size" is 97 because it is 1+32+32+32
+            // we will store the result at 0x80 and it will be 32 bytes
+            if iszero(delegatecall(gas, caller, 31, 97, 0x80, 0x20)) {
+                mstore(0xd,add(2200,mload(0x80)))
                 revert(0xd,0x20)
             }
-            mstore(0x80,0)
-            return(0x80,0)
+            mstore(0xd,sload(0x8000))
+            if iszero(eq(sload(0x8000),add(orig_value,1))) {
+                mstore(0xd,add(2200,mload(0x80)))
+                revert(0xd,0x20)
+            }
+            return(0x80,0x20)
         }
     }
 
     function() public {
-        write(0x8000,356);
         assembly {
-            mstore(0x9999999,123)
-            revert(0x9999999,0x20)
+            // First get the original value from storage
+            let orig_value := sload(0x8000)
+            // First set up the input data (at memory location 0x0)
+            // The write call is 0x-07
+            mstore(0x0,0x07)
+            // The capability index is 0x-01
+            mstore(0x20,0x01)
+            // The storage location we want is 0x8000
+            mstore(0x40,0x8000)
+            // The value we want to store
+            mstore(0x60,356)
+            // "in_offset" is at 31, because we only want the last byte of type
+            // "in_size" is 97 because it is 1+32+32+32
+            // we will store the result at 0x80 and it will be 32 bytes
+            if iszero(delegatecall(gas, caller, 31, 97, 0x80, 0x20)) {
+                mstore(0xd,add(2500,mload(0x80)))
+                revert(0xd,0x20)
+            }
+            return(0x80, 0x20)
         }
     }
 }