Remove msg.sender on Solana (#1096)

- make msg.sender illegal
- make caller yul builtin illegal

Signed-off-by: Sean Young <sean@mess.org>

CHANGELOG.md

@@ -7,6 +7,8 @@ will be documented here.
 ### Changed
 - Overriding the function selector value is now done using the `@selector([1, 2, 3, 4])`
   syntax, and the old syntax `selector=hex"12345678"` has been removed.
+- 'msg.sender' was not implemented correctly on Solana, and
+  [has now been removed](https://solang.readthedocs.io/en/latest/targets/solana.html#msg-sender-solana).
   [seanyoung](https://github.com/seanyoung)
 
 ## v0.2.0.0 Berlin

docs/examples/event_positional_fields.sol

@@ -9,11 +9,11 @@ event UserModified(
 );
 
 contract user {
-    function set_name(string name) public {
-        emit UserModified({ user: msg.sender, name: name });
+    function set_name(address user, string name) public {
+        emit UserModified({ user: user, name: name });
     }
 
-    function set_groupid(uint64 id) public {
-        emit UserModified({ user: msg.sender, groupid: id });
+    function set_groupid(address user, uint64 id) public {
+        emit UserModified({ user: user, groupid: id });
     }
 }

docs/examples/solana/use_authority.sol

@@ -0,0 +1,36 @@
+import 'solana';
+
+contract AuthorityExample {
+    address authority;
+    uint64 counter;
+
+    modifier needs_authority() {
+        for (uint64 i = 0; i < tx.accounts.length; i++) {
+            AccountInfo ai = tx.accounts[i];
+
+            if (ai.key == authority && ai.is_signer) {
+                _;
+                return;
+            }
+        }
+
+        print("not signed by authority");
+        revert();
+    }
+
+    constructor(address initial_authority) {
+        authority = initial_authority;
+    }
+
+    function set_new_authority(address new_authority) needs_authority public {
+        authority = new_authority;
+    }
+
+    function inc() needs_authority public {
+        counter += 1;
+    }
+
+    function get() public view returns (uint64) {
+        return counter;
+    }
+}

docs/language/functions.rst

@@ -221,13 +221,19 @@ Function modifiers are used to check pre-conditions or post-conditions for a fun
 new modifier must be declared which looks much like a function, but uses the ``modifier``
 keyword rather than ``function``.
 
-.. include:: ../examples/function_modifier.sol
+.. include:: ../examples/substrate/function_modifier.sol
   :code: solidity
 
 The function `foo` can only be run by the owner of the contract, else the ``require()`` in its
 modifier will fail. The special symbol ``_;`` will be replaced by body of the function. In fact,
 if you specify ``_;`` twice, the function will execute twice, which might not be a good idea.
 
+On Solana, ``msg.sender`` does not exist, so the usual way to implement a similar test is using
+an `authority` accounts rather than an owner account.
+
+.. include:: ../examples/solana/use_authority.sol
+  :code: solidity
+
 A modifier cannot have visibility (e.g. ``public``) or mutability (e.g. ``view``) specified,
 since a modifier is never externally callable. Modifiers can only be used by attaching them
 to functions.
@@ -247,13 +253,13 @@ this example, the `only_owner` modifier is run first, and if that reaches ``_;``
 `check_price` is executed. The body of function `foo()` is only reached once `check_price()`
 reaches ``_;``.
 
-.. include:: ../examples/function_multiple_modifiers.sol
+.. include:: ../examples/substrate/function_multiple_modifiers.sol
   :code: solidity
 
 Modifiers can be inherited or declared ``virtual`` in a base contract and then overriden, exactly like
 functions can be.
 
-.. include:: ../examples/function_override_modifiers.sol
+.. include:: ../examples/substrate/function_override_modifiers.sol
   :code: solidity
 
 Calling an external function using ``call()``

docs/targets/solana.rst

@@ -184,6 +184,28 @@ this. The balance of an account can be credited without any code being executed.
 
 ``receive()`` functions are not permitted on the Solana target.
 
+.. _msg_sender_solana:
+
+``msg.sender`` not available on Solana
+______________________________________
+
+On Ethereum, ``msg.sender`` is used to identify either the account that submitted
+the transaction, or the caller when one contract calls another. On Ethereum, each
+contract execution can only use a single account, which provides the code and data.
+On Solana, each contract execution uses many accounts. Consider a rust contract which
+calls a Solidity contract: the rust contract can access a few data accounts, and which
+of those would be considered the caller? So in many cases there is not a single account
+which can be identified as a caller. In addition to that, the Solana VM has no
+mechanism for fetching the caller accounts. This means there is no way to implement
+``msg.sender``.
+
+The way to implement this on Solana is to have an authority account for the contract
+that must be a signer for the transaction (note that on Solana there
+can be many signers too). This is a common construct on Solana contracts.
+
+.. include:: ../examples/solana/use_authority.sol
+  :code: solidity
+
 Builtin Imports
 ________________
 

src/sema/builtin.rs

@@ -854,6 +854,14 @@ pub fn builtin_var(
                     ),
                 ));
             }
+            if ns.target == Target::Solana && p.builtin == Builtin::Sender {
+                diagnostics.push(Diagnostic::error(
+                    *loc,
+                    String::from(
+                        "'msg.sender' is not available on Solana. See https://solang.readthedocs.io/en/latest/targets/solana.html#msg-sender-solana",
+                    ),
+                ));
+            }
             return Some((p.builtin, p.ret[0].clone()));
         }
     }

src/sema/yul/builtin.rs

@@ -623,7 +623,7 @@ static YUL_BUILTIN: [YulBuiltinPrototype; 76] =
             doc: "Returns the call sender",
             ty: YulBuiltInFunction::Caller,
             stops_execution: false,
-            availability: [true, true, true],
+            availability: [true, true, false],
         },
         YulBuiltinPrototype {
             name: "callvalue",

tests/contract_testcases/solana/account_info.sol

@@ -17,7 +17,7 @@ contract c {
 
 	function notpub(AccountInfo) private returns (AccountInfo) {
 		AccountInfo ai = tx.accounts[1];
-		ai.key = msg.sender;
+		ai.key = address(this);
 		ai.lamports += 1;
 		return tx.accounts[1];
 	}

tests/contract_testcases/solana/account_meta.dot

@@ -2,13 +2,13 @@ strict digraph "tests/contract_testcases/solana/account_meta.sol" {
 	contract [label="contract spl\ntests/contract_testcases/solana/account_meta.sol:3:1-18:2"]
 	foo [label="function foo\ncontract: spl\ntests/contract_testcases/solana/account_meta.sol:4:2-47\nsignature foo()\nvisibility public\nmutability nonpayable"]
 	returns [label="returns\nbool \naddress "]
-	var_decl [label="variable decl struct AccountMeta meta\ntests/contract_testcases/solana/account_meta.sol:5:3-75"]
-	struct_literal [label="struct literal: struct AccountMeta\ntests/contract_testcases/solana/account_meta.sol:5:26-75"]
-	getref [label="getref address\ntests/contract_testcases/solana/account_meta.sol:5:26-75"]
-	cast [label="cast address\ntests/contract_testcases/solana/account_meta.sol:5:42-61"]
-	builtins [label="builtin Sender\ntests/contract_testcases/solana/account_meta.sol:5:50-60"]
-	bool_literal [label="bool literal: true\ntests/contract_testcases/solana/account_meta.sol:5:63-67"]
-	bool_literal_10 [label="bool literal: false\ntests/contract_testcases/solana/account_meta.sol:5:69-74"]
+	var_decl [label="variable decl struct AccountMeta meta\ntests/contract_testcases/solana/account_meta.sol:5:3-69"]
+	struct_literal [label="struct literal: struct AccountMeta\ntests/contract_testcases/solana/account_meta.sol:5:26-69"]
+	getref [label="getref address\ntests/contract_testcases/solana/account_meta.sol:5:26-69"]
+	cast [label="cast address\ntests/contract_testcases/solana/account_meta.sol:5:42-55"]
+	builtins [label="builtin GetAddress\ntests/contract_testcases/solana/account_meta.sol:5:50-54"]
+	bool_literal [label="bool literal: true\ntests/contract_testcases/solana/account_meta.sol:5:57-61"]
+	bool_literal_10 [label="bool literal: false\ntests/contract_testcases/solana/account_meta.sol:5:63-68"]
 	return [label="return\ntests/contract_testcases/solana/account_meta.sol:6:3-41"]
 	list [label="list\ntests/contract_testcases/solana/account_meta.sol:6:3-41"]
 	load [label="load bool\ntests/contract_testcases/solana/account_meta.sol:6:3-41"]

tests/contract_testcases/solana/account_meta.sol

@@ -2,7 +2,7 @@ import "solana" as sol;
 
 contract spl {
 	function foo() public returns (bool, address) {
-		sol.AccountMeta meta = sol.AccountMeta(address(msg.sender), true, false);
+		sol.AccountMeta meta = sol.AccountMeta(address(this), true, false);
 		return (meta.is_writable, meta.pubkey);
 	}
 

tests/contract_testcases/solana/address_cast.sol

@@ -3,6 +3,6 @@ contract c {
 		// We have code that cast address type to ref address
 		// in fn sema::cast(). Ensure that this does not cause
 		// address values to be assignable.
-		address(0) = msg.sender;
+		address(0) = tx.program_id;
 	}
 }

tests/contract_testcases/solana/address_member_call.dot

@@ -65,8 +65,8 @@ strict digraph "tests/contract_testcases/solana/address_member_call.sol" {
 	variable_65 [label="variable: _amounts\nuint64[]\ntests/contract_testcases/solana/address_member_call.sol:34:45-53"]
 	variable_66 [label="variable: i\nuint8\ntests/contract_testcases/solana/address_member_call.sol:34:54-55"]
 	emit [label="emit\nevent MyContract.Receipt\ntests/contract_testcases/solana/address_member_call.sol:37:9-43:10"]
-	cast_68 [label="cast address\ntests/contract_testcases/solana/address_member_call.sol:38:13-23"]
-	builtins_69 [label="builtin Sender\ntests/contract_testcases/solana/address_member_call.sol:38:13-23"]
+	cast_68 [label="cast address\ntests/contract_testcases/solana/address_member_call.sol:38:13-26"]
+	builtins_69 [label="builtin GetAddress\ntests/contract_testcases/solana/address_member_call.sol:38:21-25"]
 	number_literal_70 [label="address literal: 0\ntests/contract_testcases/solana/address_member_call.sol:39:13-54"]
 	variable_71 [label="variable: _receivers\naddress[]\ntests/contract_testcases/solana/address_member_call.sol:40:13-23"]
 	variable_72 [label="variable: _amounts\nuint64[]\ntests/contract_testcases/solana/address_member_call.sol:41:13-21"]

tests/contract_testcases/solana/address_member_call.sol

@@ -10,7 +10,7 @@ contract MyContract {
         string Payment
     );
 
-    function send( 
+    function send(
         address[] calldata _receivers,
         uint64[] calldata _amounts,
         string calldata _payment,
@@ -35,7 +35,7 @@ contract MyContract {
         }
 
         emit Receipt(
-            msg.sender,
+            address(this),
             address"11111111111111111111111111111111",
             _receivers,
             _amounts,

tests/contract_testcases/solana/issues678.dot

@@ -3,316 +3,328 @@ strict digraph "tests/contract_testcases/solana/issues678.sol" {
 	Transfer [label="name:Transfer\ncontract: 0\ntests/contract_testcases/solana/issues678.sol:5:11-19\nfield name:to ty:address indexed:no\nfield name:amount ty:uint256 indexed:no\nfield name:balance ty:uint256 indexed:no"]
 	contract [label="contract Shares\ntests/contract_testcases/solana/issues678.sol:4:1-56:2"]
 	var [label="variable _shares\nvisibility private\ntests/contract_testcases/solana/issues678.sol:12:5-28"]
-	node_7 [label="constructor \ncontract: Shares\ntests/contract_testcases/solana/issues678.sol:15:5-19\nsignature ()\nvisibility public\nmutability nonpayable"]
+	node_7 [label="constructor \ncontract: Shares\ntests/contract_testcases/solana/issues678.sol:15:5-41\nsignature (bytes32)\nvisibility public\nmutability nonpayable"]
 	tags [label="notice: Create the shares object that gives the shares to every body"]
-	expr [label="expression\ntests/contract_testcases/solana/issues678.sol:16:9-46"]
+	parameters [label="parameters\naddress payable sender"]
+	expr [label="expression\ntests/contract_testcases/solana/issues678.sol:16:9-42"]
 	builtins [label="builtin ArrayPush\ntests/contract_testcases/solana/issues678.sol:16:17-21"]
 	storage_var [label="storage variable\nShares._shares\nstruct Shares.Share[] storage\ntests/contract_testcases/solana/issues678.sol:16:9-16"]
-	struct_literal [label="struct literal: struct Shares.Share\ntests/contract_testcases/solana/issues678.sol:16:22-45"]
-	builtins_13 [label="builtin Sender\ntests/contract_testcases/solana/issues678.sol:16:28-38"]
-	number_literal [label="uint256 literal: 1000\ntests/contract_testcases/solana/issues678.sol:16:40-44"]
+	struct_literal [label="struct literal: struct Shares.Share\ntests/contract_testcases/solana/issues678.sol:16:22-41"]
+	variable [label="variable: sender\naddress payable\ntests/contract_testcases/solana/issues678.sol:16:28-34"]
+	number_literal [label="uint256 literal: 1000\ntests/contract_testcases/solana/issues678.sol:16:36-40"]
 	getShares [label="function getShares\ncontract: Shares\ntests/contract_testcases/solana/issues678.sol:19:5-80\nsignature getShares()\nvisibility external\nmutability view"]
 	returns [label="returns\naddress[] \nuint256[] "]
 	var_decl [label="variable decl address[] retAddress\ntests/contract_testcases/solana/issues678.sol:20:9-76"]
 	alloc_array [label="alloc array address[]\ntests/contract_testcases/solana/issues678.sol:20:39-76"]
 	array_length [label="array length uint32\nelement struct Shares.Share\ntests/contract_testcases/solana/issues678.sol:20:68-74"]
-	storage_var_20 [label="storage variable\nShares._shares\nstruct Shares.Share[] storage\ntests/contract_testcases/solana/issues678.sol:20:60-67"]
-	var_decl_21 [label="variable decl uint256[] retShare\ntests/contract_testcases/solana/issues678.sol:21:9-68"]
-	alloc_array_22 [label="alloc array uint256[]\ntests/contract_testcases/solana/issues678.sol:21:34-68"]
-	array_length_23 [label="array length uint32\nelement struct Shares.Share\ntests/contract_testcases/solana/issues678.sol:21:60-66"]
-	storage_var_24 [label="storage variable\nShares._shares\nstruct Shares.Share[] storage\ntests/contract_testcases/solana/issues678.sol:21:52-59"]
+	storage_var_21 [label="storage variable\nShares._shares\nstruct Shares.Share[] storage\ntests/contract_testcases/solana/issues678.sol:20:60-67"]
+	var_decl_22 [label="variable decl uint256[] retShare\ntests/contract_testcases/solana/issues678.sol:21:9-68"]
+	alloc_array_23 [label="alloc array uint256[]\ntests/contract_testcases/solana/issues678.sol:21:34-68"]
+	array_length_24 [label="array length uint32\nelement struct Shares.Share\ntests/contract_testcases/solana/issues678.sol:21:60-66"]
+	storage_var_25 [label="storage variable\nShares._shares\nstruct Shares.Share[] storage\ntests/contract_testcases/solana/issues678.sol:21:52-59"]
 	for [label="for\ntests/contract_testcases/solana/issues678.sol:22:9-25:10"]
-	var_decl_26 [label="variable decl uint256 i\ntests/contract_testcases/solana/issues678.sol:22:14-24"]
-	number_literal_27 [label="uint256 literal: 0\ntests/contract_testcases/solana/issues678.sol:22:23-24"]
+	var_decl_27 [label="variable decl uint256 i\ntests/contract_testcases/solana/issues678.sol:22:14-24"]
+	number_literal_28 [label="uint256 literal: 0\ntests/contract_testcases/solana/issues678.sol:22:23-24"]
 	less [label="less\ntests/contract_testcases/solana/issues678.sol:22:26-44"]
-	variable [label="variable: i\nuint256\ntests/contract_testcases/solana/issues678.sol:22:26-27"]
+	variable_30 [label="variable: i\nuint256\ntests/contract_testcases/solana/issues678.sol:22:26-27"]
 	zero_ext [label="zero extend uint256\ntests/contract_testcases/solana/issues678.sol:22:30-44"]
-	array_length_31 [label="array length uint32\nelement struct Shares.Share\ntests/contract_testcases/solana/issues678.sol:22:38-44"]
-	storage_var_32 [label="storage variable\nShares._shares\nstruct Shares.Share[] storage\ntests/contract_testcases/solana/issues678.sol:22:30-37"]
-	expr_33 [label="expression\ntests/contract_testcases/solana/issues678.sol:22:46-49"]
+	array_length_32 [label="array length uint32\nelement struct Shares.Share\ntests/contract_testcases/solana/issues678.sol:22:38-44"]
+	storage_var_33 [label="storage variable\nShares._shares\nstruct Shares.Share[] storage\ntests/contract_testcases/solana/issues678.sol:22:30-37"]
+	expr_34 [label="expression\ntests/contract_testcases/solana/issues678.sol:22:46-49"]
 	post_increment [label="post increment\nuint256\ntests/contract_testcases/solana/issues678.sol:22:46-49"]
-	variable_35 [label="variable: i\nuint256\ntests/contract_testcases/solana/issues678.sol:22:46-47"]
-	expr_36 [label="expression\ntests/contract_testcases/solana/issues678.sol:23:13-50"]
+	variable_36 [label="variable: i\nuint256\ntests/contract_testcases/solana/issues678.sol:22:46-47"]
+	expr_37 [label="expression\ntests/contract_testcases/solana/issues678.sol:23:13-50"]
 	assign [label="assign\naddress\ntests/contract_testcases/solana/issues678.sol:23:13-50"]
 	subscript [label="subscript address[]\ntests/contract_testcases/solana/issues678.sol:23:13-26"]
-	variable_39 [label="variable: retAddress\naddress[]\ntests/contract_testcases/solana/issues678.sol:23:13-23"]
-	variable_40 [label="variable: i\nuint256\ntests/contract_testcases/solana/issues678.sol:23:24-25"]
+	variable_40 [label="variable: retAddress\naddress[]\ntests/contract_testcases/solana/issues678.sol:23:13-23"]
+	variable_41 [label="variable: i\nuint256\ntests/contract_testcases/solana/issues678.sol:23:24-25"]
 	cast [label="cast address\ntests/contract_testcases/solana/issues678.sol:23:29-50"]
 	storage_load [label="storage load address payable\ntests/contract_testcases/solana/issues678.sol:23:29-50"]
 	structmember [label="struct member #0 address payable storage\ntests/contract_testcases/solana/issues678.sol:23:40-50"]
-	subscript_44 [label="subscript struct Shares.Share[] storage\ntests/contract_testcases/solana/issues678.sol:23:29-39"]
-	storage_var_45 [label="storage variable\nShares._shares\nstruct Shares.Share[] storage\ntests/contract_testcases/solana/issues678.sol:23:29-36"]
-	variable_46 [label="variable: i\nuint256\ntests/contract_testcases/solana/issues678.sol:23:37-38"]
-	expr_47 [label="expression\ntests/contract_testcases/solana/issues678.sol:24:13-44"]
-	assign_48 [label="assign\nuint256\ntests/contract_testcases/solana/issues678.sol:24:13-44"]
-	subscript_49 [label="subscript uint256[]\ntests/contract_testcases/solana/issues678.sol:24:13-24"]
-	variable_50 [label="variable: retShare\nuint256[]\ntests/contract_testcases/solana/issues678.sol:24:13-21"]
-	variable_51 [label="variable: i\nuint256\ntests/contract_testcases/solana/issues678.sol:24:22-23"]
-	storage_load_52 [label="storage load uint256\ntests/contract_testcases/solana/issues678.sol:24:27-44"]
-	structmember_53 [label="struct member #1 uint256 storage\ntests/contract_testcases/solana/issues678.sol:24:38-44"]
-	subscript_54 [label="subscript struct Shares.Share[] storage\ntests/contract_testcases/solana/issues678.sol:24:27-37"]
-	storage_var_55 [label="storage variable\nShares._shares\nstruct Shares.Share[] storage\ntests/contract_testcases/solana/issues678.sol:24:27-34"]
-	variable_56 [label="variable: i\nuint256\ntests/contract_testcases/solana/issues678.sol:24:35-36"]
+	subscript_45 [label="subscript struct Shares.Share[] storage\ntests/contract_testcases/solana/issues678.sol:23:29-39"]
+	storage_var_46 [label="storage variable\nShares._shares\nstruct Shares.Share[] storage\ntests/contract_testcases/solana/issues678.sol:23:29-36"]
+	variable_47 [label="variable: i\nuint256\ntests/contract_testcases/solana/issues678.sol:23:37-38"]
+	expr_48 [label="expression\ntests/contract_testcases/solana/issues678.sol:24:13-44"]
+	assign_49 [label="assign\nuint256\ntests/contract_testcases/solana/issues678.sol:24:13-44"]
+	subscript_50 [label="subscript uint256[]\ntests/contract_testcases/solana/issues678.sol:24:13-24"]
+	variable_51 [label="variable: retShare\nuint256[]\ntests/contract_testcases/solana/issues678.sol:24:13-21"]
+	variable_52 [label="variable: i\nuint256\ntests/contract_testcases/solana/issues678.sol:24:22-23"]
+	storage_load_53 [label="storage load uint256\ntests/contract_testcases/solana/issues678.sol:24:27-44"]
+	structmember_54 [label="struct member #1 uint256 storage\ntests/contract_testcases/solana/issues678.sol:24:38-44"]
+	subscript_55 [label="subscript struct Shares.Share[] storage\ntests/contract_testcases/solana/issues678.sol:24:27-37"]
+	storage_var_56 [label="storage variable\nShares._shares\nstruct Shares.Share[] storage\ntests/contract_testcases/solana/issues678.sol:24:27-34"]
+	variable_57 [label="variable: i\nuint256\ntests/contract_testcases/solana/issues678.sol:24:35-36"]
 	return [label="return\ntests/contract_testcases/solana/issues678.sol:26:9-38"]
 	list [label="list\ntests/contract_testcases/solana/issues678.sol:26:9-38"]
-	variable_59 [label="variable: retAddress\naddress[]\ntests/contract_testcases/solana/issues678.sol:26:17-27"]
-	variable_60 [label="variable: retShare\nuint256[]\ntests/contract_testcases/solana/issues678.sol:26:29-37"]
-	_senderIsAShareOwner [label="function _senderIsAShareOwner\ncontract: Shares\ntests/contract_testcases/solana/issues678.sol:29:5-64\nsignature _senderIsAShareOwner()\nvisibility private\nmutability view"]
-	returns_62 [label="returns\nbool "]
-	for_63 [label="for\ntests/contract_testcases/solana/issues678.sol:30:9-34:10"]
-	var_decl_64 [label="variable decl uint256 i\ntests/contract_testcases/solana/issues678.sol:30:14-24"]
-	number_literal_65 [label="uint256 literal: 0\ntests/contract_testcases/solana/issues678.sol:30:23-24"]
-	less_66 [label="less\ntests/contract_testcases/solana/issues678.sol:30:26-44"]
-	variable_67 [label="variable: i\nuint256\ntests/contract_testcases/solana/issues678.sol:30:26-27"]
-	zero_ext_68 [label="zero extend uint256\ntests/contract_testcases/solana/issues678.sol:30:30-44"]
-	array_length_69 [label="array length uint32\nelement struct Shares.Share\ntests/contract_testcases/solana/issues678.sol:30:38-44"]
-	storage_var_70 [label="storage variable\nShares._shares\nstruct Shares.Share[] storage\ntests/contract_testcases/solana/issues678.sol:30:30-37"]
-	expr_71 [label="expression\ntests/contract_testcases/solana/issues678.sol:30:46-49"]
-	post_increment_72 [label="post increment\nuint256\ntests/contract_testcases/solana/issues678.sol:30:46-49"]
-	variable_73 [label="variable: i\nuint256\ntests/contract_testcases/solana/issues678.sol:30:46-47"]
+	variable_60 [label="variable: retAddress\naddress[]\ntests/contract_testcases/solana/issues678.sol:26:17-27"]
+	variable_61 [label="variable: retShare\nuint256[]\ntests/contract_testcases/solana/issues678.sol:26:29-37"]
+	_senderIsAShareOwner [label="function _senderIsAShareOwner\ncontract: Shares\ntests/contract_testcases/solana/issues678.sol:29:5-78\nsignature _senderIsAShareOwner(bytes32)\nvisibility private\nmutability view"]
+	parameters_63 [label="parameters\naddress sender"]
+	returns_64 [label="returns\nbool "]
+	for_65 [label="for\ntests/contract_testcases/solana/issues678.sol:30:9-34:10"]
+	var_decl_66 [label="variable decl uint256 i\ntests/contract_testcases/solana/issues678.sol:30:14-24"]
+	number_literal_67 [label="uint256 literal: 0\ntests/contract_testcases/solana/issues678.sol:30:23-24"]
+	less_68 [label="less\ntests/contract_testcases/solana/issues678.sol:30:26-44"]
+	variable_69 [label="variable: i\nuint256\ntests/contract_testcases/solana/issues678.sol:30:26-27"]
+	zero_ext_70 [label="zero extend uint256\ntests/contract_testcases/solana/issues678.sol:30:30-44"]
+	array_length_71 [label="array length uint32\nelement struct Shares.Share\ntests/contract_testcases/solana/issues678.sol:30:38-44"]
+	storage_var_72 [label="storage variable\nShares._shares\nstruct Shares.Share[] storage\ntests/contract_testcases/solana/issues678.sol:30:30-37"]
+	expr_73 [label="expression\ntests/contract_testcases/solana/issues678.sol:30:46-49"]
+	post_increment_74 [label="post increment\nuint256\ntests/contract_testcases/solana/issues678.sol:30:46-49"]
+	variable_75 [label="variable: i\nuint256\ntests/contract_testcases/solana/issues678.sol:30:46-47"]
 	if [label="if\ntests/contract_testcases/solana/issues678.sol:31:13-33:14"]
-	equal [label="equal\ntests/contract_testcases/solana/issues678.sol:31:17-52"]
-	storage_load_76 [label="storage load address payable\ntests/contract_testcases/solana/issues678.sol:31:17-38"]
-	structmember_77 [label="struct member #0 address payable storage\ntests/contract_testcases/solana/issues678.sol:31:28-38"]
-	subscript_78 [label="subscript struct Shares.Share[] storage\ntests/contract_testcases/solana/issues678.sol:31:17-27"]
-	storage_var_79 [label="storage variable\nShares._shares\nstruct Shares.Share[] storage\ntests/contract_testcases/solana/issues678.sol:31:17-24"]
-	variable_80 [label="variable: i\nuint256\ntests/contract_testcases/solana/issues678.sol:31:25-26"]
-	builtins_81 [label="builtin Sender\ntests/contract_testcases/solana/issues678.sol:31:42-52"]
-	return_82 [label="return\ntests/contract_testcases/solana/issues678.sol:32:17-28"]
+	equal [label="equal\ntests/contract_testcases/solana/issues678.sol:31:17-48"]
+	cast_78 [label="cast address\ntests/contract_testcases/solana/issues678.sol:31:17-38"]
+	storage_load_79 [label="storage load address payable\ntests/contract_testcases/solana/issues678.sol:31:17-38"]
+	structmember_80 [label="struct member #0 address payable storage\ntests/contract_testcases/solana/issues678.sol:31:28-38"]
+	subscript_81 [label="subscript struct Shares.Share[] storage\ntests/contract_testcases/solana/issues678.sol:31:17-27"]
+	storage_var_82 [label="storage variable\nShares._shares\nstruct Shares.Share[] storage\ntests/contract_testcases/solana/issues678.sol:31:17-24"]
+	variable_83 [label="variable: i\nuint256\ntests/contract_testcases/solana/issues678.sol:31:25-26"]
+	variable_84 [label="variable: sender\naddress\ntests/contract_testcases/solana/issues678.sol:31:42-48"]
+	return_85 [label="return\ntests/contract_testcases/solana/issues678.sol:32:17-28"]
 	bool_literal [label="bool literal: true\ntests/contract_testcases/solana/issues678.sol:32:24-28"]
-	return_84 [label="return\ntests/contract_testcases/solana/issues678.sol:35:9-21"]
-	bool_literal_85 [label="bool literal: false\ntests/contract_testcases/solana/issues678.sol:35:16-21"]
-	withdraw [label="function withdraw\ncontract: Shares\ntests/contract_testcases/solana/issues678.sol:41:5-33\nsignature withdraw()\nvisibility external\nmutability nonpayable"]
-	tags_87 [label="dev: Allow a share owner to retrieve his money. It empty the money contained inside of the smart contract to give it to owners."]
-	expr_88 [label="expression\ntests/contract_testcases/solana/issues678.sol:42:9-91"]
-	builtins_89 [label="builtin Require\ntests/contract_testcases/solana/issues678.sol:42:9-16"]
-	call_internal_function [label="call internal function\ntests/contract_testcases/solana/issues678.sol:42:17-39"]
-	internal_function [label="function() internal view returns (bool)\nShares._senderIsAShareOwner\ntests/contract_testcases/solana/issues678.sol:42:17-39"]
-	alloc_array_92 [label="alloc array string\ninitializer: 596f752063616e277420776974686472617720696620796f7520617265206e6f742061207368617265206f776e6572\ntests/contract_testcases/solana/issues678.sol:42:41-90"]
-	number_literal_93 [label="uint32 literal: 47\ntests/contract_testcases/solana/issues678.sol:42:41-90"]
-	var_decl_94 [label="variable decl uint256 curr_balance\ntests/contract_testcases/solana/issues678.sol:43:9-50"]
+	return_87 [label="return\ntests/contract_testcases/solana/issues678.sol:35:9-21"]
+	bool_literal_88 [label="bool literal: false\ntests/contract_testcases/solana/issues678.sol:35:16-21"]
+	withdraw [label="function withdraw\ncontract: Shares\ntests/contract_testcases/solana/issues678.sol:41:5-47\nsignature withdraw(bytes32)\nvisibility external\nmutability nonpayable"]
+	tags_90 [label="dev: Allow a share owner to retrieve his money. It empty the money contained inside of the smart contract to give it to owners."]
+	parameters_91 [label="parameters\naddress sender"]
+	expr_92 [label="expression\ntests/contract_testcases/solana/issues678.sol:42:9-97"]
+	builtins_93 [label="builtin Require\ntests/contract_testcases/solana/issues678.sol:42:9-16"]
+	call_internal_function [label="call internal function\ntests/contract_testcases/solana/issues678.sol:42:17-45"]
+	internal_function [label="function(address) internal view returns (bool)\nShares._senderIsAShareOwner\ntests/contract_testcases/solana/issues678.sol:42:17-45"]
+	variable_96 [label="variable: sender\naddress\ntests/contract_testcases/solana/issues678.sol:42:38-44"]
+	alloc_array_97 [label="alloc array string\ninitializer: 596f752063616e277420776974686472617720696620796f7520617265206e6f742061207368617265206f776e6572\ntests/contract_testcases/solana/issues678.sol:42:47-96"]
+	number_literal_98 [label="uint32 literal: 47\ntests/contract_testcases/solana/issues678.sol:42:47-96"]
+	var_decl_99 [label="variable decl uint256 curr_balance\ntests/contract_testcases/solana/issues678.sol:43:9-50"]
 	sign_ext [label="sign extend uint256\ntests/contract_testcases/solana/issues678.sol:43:29-50"]
-	builtins_96 [label="builtin Balance\ntests/contract_testcases/solana/issues678.sol:43:29-50"]
-	cast_97 [label="cast address\ntests/contract_testcases/solana/issues678.sol:43:29-42"]
-	builtins_98 [label="builtin GetAddress\ntests/contract_testcases/solana/issues678.sol:43:37-41"]
-	expr_99 [label="expression\ntests/contract_testcases/solana/issues678.sol:44:9-66"]
-	builtins_100 [label="builtin Require\ntests/contract_testcases/solana/issues678.sol:44:9-16"]
+	builtins_101 [label="builtin Balance\ntests/contract_testcases/solana/issues678.sol:43:29-50"]
+	cast_102 [label="cast address\ntests/contract_testcases/solana/issues678.sol:43:29-42"]
+	builtins_103 [label="builtin GetAddress\ntests/contract_testcases/solana/issues678.sol:43:37-41"]
+	expr_104 [label="expression\ntests/contract_testcases/solana/issues678.sol:44:9-66"]
+	builtins_105 [label="builtin Require\ntests/contract_testcases/solana/issues678.sol:44:9-16"]
 	more [label="more\ntests/contract_testcases/solana/issues678.sol:44:17-33"]
-	variable_102 [label="variable: curr_balance\nuint256\ntests/contract_testcases/solana/issues678.sol:44:17-29"]
-	number_literal_103 [label="uint256 literal: 0\ntests/contract_testcases/solana/issues678.sol:44:32-33"]
-	alloc_array_104 [label="alloc array string\ninitializer: 5468657265206973206e6f7468696e6720746f207769746864726177\ntests/contract_testcases/solana/issues678.sol:44:35-65"]
-	number_literal_105 [label="uint32 literal: 28\ntests/contract_testcases/solana/issues678.sol:44:35-65"]
-	for_106 [label="for\ntests/contract_testcases/solana/issues678.sol:45:9-49:10"]
-	var_decl_107 [label="variable decl uint256 i\ntests/contract_testcases/solana/issues678.sol:45:14-24"]
-	number_literal_108 [label="uint256 literal: 0\ntests/contract_testcases/solana/issues678.sol:45:23-24"]
-	less_109 [label="less\ntests/contract_testcases/solana/issues678.sol:45:26-44"]
-	variable_110 [label="variable: i\nuint256\ntests/contract_testcases/solana/issues678.sol:45:26-27"]
-	zero_ext_111 [label="zero extend uint256\ntests/contract_testcases/solana/issues678.sol:45:30-44"]
-	array_length_112 [label="array length uint32\nelement struct Shares.Share\ntests/contract_testcases/solana/issues678.sol:45:38-44"]
-	storage_var_113 [label="storage variable\nShares._shares\nstruct Shares.Share[] storage\ntests/contract_testcases/solana/issues678.sol:45:30-37"]
-	expr_114 [label="expression\ntests/contract_testcases/solana/issues678.sol:45:46-49"]
-	post_increment_115 [label="post increment\nuint256\ntests/contract_testcases/solana/issues678.sol:45:46-49"]
-	variable_116 [label="variable: i\nuint256\ntests/contract_testcases/solana/issues678.sol:45:46-47"]
-	var_decl_117 [label="variable decl uint256 to_transfer\ntests/contract_testcases/solana/issues678.sol:46:13-71"]
+	variable_107 [label="variable: curr_balance\nuint256\ntests/contract_testcases/solana/issues678.sol:44:17-29"]
+	number_literal_108 [label="uint256 literal: 0\ntests/contract_testcases/solana/issues678.sol:44:32-33"]
+	alloc_array_109 [label="alloc array string\ninitializer: 5468657265206973206e6f7468696e6720746f207769746864726177\ntests/contract_testcases/solana/issues678.sol:44:35-65"]
+	number_literal_110 [label="uint32 literal: 28\ntests/contract_testcases/solana/issues678.sol:44:35-65"]
+	for_111 [label="for\ntests/contract_testcases/solana/issues678.sol:45:9-49:10"]
+	var_decl_112 [label="variable decl uint256 i\ntests/contract_testcases/solana/issues678.sol:45:14-24"]
+	number_literal_113 [label="uint256 literal: 0\ntests/contract_testcases/solana/issues678.sol:45:23-24"]
+	less_114 [label="less\ntests/contract_testcases/solana/issues678.sol:45:26-44"]
+	variable_115 [label="variable: i\nuint256\ntests/contract_testcases/solana/issues678.sol:45:26-27"]
+	zero_ext_116 [label="zero extend uint256\ntests/contract_testcases/solana/issues678.sol:45:30-44"]
+	array_length_117 [label="array length uint32\nelement struct Shares.Share\ntests/contract_testcases/solana/issues678.sol:45:38-44"]
+	storage_var_118 [label="storage variable\nShares._shares\nstruct Shares.Share[] storage\ntests/contract_testcases/solana/issues678.sol:45:30-37"]
+	expr_119 [label="expression\ntests/contract_testcases/solana/issues678.sol:45:46-49"]
+	post_increment_120 [label="post increment\nuint256\ntests/contract_testcases/solana/issues678.sol:45:46-49"]
+	variable_121 [label="variable: i\nuint256\ntests/contract_testcases/solana/issues678.sol:45:46-47"]
+	var_decl_122 [label="variable decl uint256 to_transfer\ntests/contract_testcases/solana/issues678.sol:46:13-71"]
 	divide [label="divide\nuint256\ntests/contract_testcases/solana/issues678.sol:46:32-71"]
 	multiply [label="multiply\nuint256\ntests/contract_testcases/solana/issues678.sol:46:32-64"]
-	variable_120 [label="variable: curr_balance\nuint256\ntests/contract_testcases/solana/issues678.sol:46:32-44"]
-	storage_load_121 [label="storage load uint256\ntests/contract_testcases/solana/issues678.sol:46:47-64"]
-	structmember_122 [label="struct member #1 uint256 storage\ntests/contract_testcases/solana/issues678.sol:46:58-64"]
-	subscript_123 [label="subscript struct Shares.Share[] storage\ntests/contract_testcases/solana/issues678.sol:46:47-57"]
-	storage_var_124 [label="storage variable\nShares._shares\nstruct Shares.Share[] storage\ntests/contract_testcases/solana/issues678.sol:46:47-54"]
-	variable_125 [label="variable: i\nuint256\ntests/contract_testcases/solana/issues678.sol:46:55-56"]
-	number_literal_126 [label="uint256 literal: 1000\ntests/contract_testcases/solana/issues678.sol:46:67-71"]
-	expr_127 [label="expression\ntests/contract_testcases/solana/issues678.sol:47:13-64"]
-	builtins_128 [label="builtin PayableTransfer\ntests/contract_testcases/solana/issues678.sol:47:13-64"]
-	storage_load_129 [label="storage load address payable\ntests/contract_testcases/solana/issues678.sol:47:24-34"]
-	structmember_130 [label="struct member #0 address payable storage\ntests/contract_testcases/solana/issues678.sol:47:24-34"]
-	subscript_131 [label="subscript struct Shares.Share[] storage\ntests/contract_testcases/solana/issues678.sol:47:13-23"]
-	storage_var_132 [label="storage variable\nShares._shares\nstruct Shares.Share[] storage\ntests/contract_testcases/solana/issues678.sol:47:13-20"]
-	variable_133 [label="variable: i\nuint256\ntests/contract_testcases/solana/issues678.sol:47:21-22"]
-	cast_134 [label="cast uint64\ntests/contract_testcases/solana/issues678.sol:47:44-63"]
+	variable_125 [label="variable: curr_balance\nuint256\ntests/contract_testcases/solana/issues678.sol:46:32-44"]
+	storage_load_126 [label="storage load uint256\ntests/contract_testcases/solana/issues678.sol:46:47-64"]
+	structmember_127 [label="struct member #1 uint256 storage\ntests/contract_testcases/solana/issues678.sol:46:58-64"]
+	subscript_128 [label="subscript struct Shares.Share[] storage\ntests/contract_testcases/solana/issues678.sol:46:47-57"]
+	storage_var_129 [label="storage variable\nShares._shares\nstruct Shares.Share[] storage\ntests/contract_testcases/solana/issues678.sol:46:47-54"]
+	variable_130 [label="variable: i\nuint256\ntests/contract_testcases/solana/issues678.sol:46:55-56"]
+	number_literal_131 [label="uint256 literal: 1000\ntests/contract_testcases/solana/issues678.sol:46:67-71"]
+	expr_132 [label="expression\ntests/contract_testcases/solana/issues678.sol:47:13-64"]
+	builtins_133 [label="builtin PayableTransfer\ntests/contract_testcases/solana/issues678.sol:47:13-64"]
+	storage_load_134 [label="storage load address payable\ntests/contract_testcases/solana/issues678.sol:47:24-34"]
+	structmember_135 [label="struct member #0 address payable storage\ntests/contract_testcases/solana/issues678.sol:47:24-34"]
+	subscript_136 [label="subscript struct Shares.Share[] storage\ntests/contract_testcases/solana/issues678.sol:47:13-23"]
+	storage_var_137 [label="storage variable\nShares._shares\nstruct Shares.Share[] storage\ntests/contract_testcases/solana/issues678.sol:47:13-20"]
+	variable_138 [label="variable: i\nuint256\ntests/contract_testcases/solana/issues678.sol:47:21-22"]
+	cast_139 [label="cast uint64\ntests/contract_testcases/solana/issues678.sol:47:44-63"]
 	trunc [label="truncate uint64\ntests/contract_testcases/solana/issues678.sol:47:44-63"]
-	variable_136 [label="variable: to_transfer\nuint256\ntests/contract_testcases/solana/issues678.sol:47:51-62"]
+	variable_141 [label="variable: to_transfer\nuint256\ntests/contract_testcases/solana/issues678.sol:47:51-62"]
 	emit [label="emit\nevent Shares.Transfer\ntests/contract_testcases/solana/issues678.sol:48:13-76"]
-	cast_138 [label="cast address\ntests/contract_testcases/solana/issues678.sol:48:38-48"]
-	storage_load_139 [label="storage load address payable\ntests/contract_testcases/solana/issues678.sol:48:38-48"]
-	structmember_140 [label="struct member #0 address payable storage\ntests/contract_testcases/solana/issues678.sol:48:38-48"]
-	subscript_141 [label="subscript struct Shares.Share[] storage\ntests/contract_testcases/solana/issues678.sol:48:27-37"]
-	storage_var_142 [label="storage variable\nShares._shares\nstruct Shares.Share[] storage\ntests/contract_testcases/solana/issues678.sol:48:27-34"]
-	variable_143 [label="variable: i\nuint256\ntests/contract_testcases/solana/issues678.sol:48:35-36"]
-	variable_144 [label="variable: to_transfer\nuint256\ntests/contract_testcases/solana/issues678.sol:48:50-61"]
-	variable_145 [label="variable: curr_balance\nuint256\ntests/contract_testcases/solana/issues678.sol:48:63-75"]
-	if_146 [label="if\ntests/contract_testcases/solana/issues678.sol:50:9-54:10"]
-	more_147 [label="more\ntests/contract_testcases/solana/issues678.sol:50:13-38"]
-	cast_148 [label="cast uint64\ntests/contract_testcases/solana/issues678.sol:50:13-34"]
-	builtins_149 [label="builtin Balance\ntests/contract_testcases/solana/issues678.sol:50:13-34"]
-	cast_150 [label="cast address\ntests/contract_testcases/solana/issues678.sol:50:13-26"]
-	builtins_151 [label="builtin GetAddress\ntests/contract_testcases/solana/issues678.sol:50:21-25"]
-	number_literal_152 [label="uint64 literal: 0\ntests/contract_testcases/solana/issues678.sol:50:37-38"]
-	expr_153 [label="expression\ntests/contract_testcases/solana/issues678.sol:53:13-64"]
-	builtins_154 [label="builtin PayableTransfer\ntests/contract_testcases/solana/issues678.sol:53:13-64"]
-	builtins_155 [label="builtin Sender\ntests/contract_testcases/solana/issues678.sol:53:21-31"]
-	builtins_156 [label="builtin Balance\ntests/contract_testcases/solana/issues678.sol:53:42-63"]
-	cast_157 [label="cast address\ntests/contract_testcases/solana/issues678.sol:53:42-55"]
-	builtins_158 [label="builtin GetAddress\ntests/contract_testcases/solana/issues678.sol:53:50-54"]
+	cast_143 [label="cast address\ntests/contract_testcases/solana/issues678.sol:48:38-48"]
+	storage_load_144 [label="storage load address payable\ntests/contract_testcases/solana/issues678.sol:48:38-48"]
+	structmember_145 [label="struct member #0 address payable storage\ntests/contract_testcases/solana/issues678.sol:48:38-48"]
+	subscript_146 [label="subscript struct Shares.Share[] storage\ntests/contract_testcases/solana/issues678.sol:48:27-37"]
+	storage_var_147 [label="storage variable\nShares._shares\nstruct Shares.Share[] storage\ntests/contract_testcases/solana/issues678.sol:48:27-34"]
+	variable_148 [label="variable: i\nuint256\ntests/contract_testcases/solana/issues678.sol:48:35-36"]
+	variable_149 [label="variable: to_transfer\nuint256\ntests/contract_testcases/solana/issues678.sol:48:50-61"]
+	variable_150 [label="variable: curr_balance\nuint256\ntests/contract_testcases/solana/issues678.sol:48:63-75"]
+	if_151 [label="if\ntests/contract_testcases/solana/issues678.sol:50:9-54:10"]
+	more_152 [label="more\ntests/contract_testcases/solana/issues678.sol:50:13-38"]
+	cast_153 [label="cast uint64\ntests/contract_testcases/solana/issues678.sol:50:13-34"]
+	builtins_154 [label="builtin Balance\ntests/contract_testcases/solana/issues678.sol:50:13-34"]
+	cast_155 [label="cast address\ntests/contract_testcases/solana/issues678.sol:50:13-26"]
+	builtins_156 [label="builtin GetAddress\ntests/contract_testcases/solana/issues678.sol:50:21-25"]
+	number_literal_157 [label="uint64 literal: 0\ntests/contract_testcases/solana/issues678.sol:50:37-38"]
+	expr_158 [label="expression\ntests/contract_testcases/solana/issues678.sol:53:13-60"]
+	builtins_159 [label="builtin PayableTransfer\ntests/contract_testcases/solana/issues678.sol:53:13-60"]
+	cast_160 [label="cast address payable\ntests/contract_testcases/solana/issues678.sol:53:13-28"]
+	variable_161 [label="variable: sender\naddress\ntests/contract_testcases/solana/issues678.sol:53:21-27"]
+	builtins_162 [label="builtin Balance\ntests/contract_testcases/solana/issues678.sol:53:38-59"]
+	cast_163 [label="cast address\ntests/contract_testcases/solana/issues678.sol:53:38-51"]
+	builtins_164 [label="builtin GetAddress\ntests/contract_testcases/solana/issues678.sol:53:46-50"]
 	diagnostic [label="pragma 'solidity' is ignored\nlevel Debug\ntests/contract_testcases/solana/issues678.sol:2:1-23"]
-	diagnostic_161 [label="found contract 'Shares'\nlevel Debug\ntests/contract_testcases/solana/issues678.sol:4:1-56:2"]
+	diagnostic_167 [label="found contract 'Shares'\nlevel Debug\ntests/contract_testcases/solana/issues678.sol:4:1-56:2"]
 	structs -> Share
 	events -> Transfer
 	contracts -> contract
 	contract -> var [label="variable"]
 	contract -> node_7 [label="constructor"]
 	node_7 -> tags [label="tags"]
+	node_7 -> parameters [label="parameters"]
 	node_7 -> expr [label="body"]
 	expr -> builtins [label="expr"]
 	builtins -> storage_var [label="arg #0"]
 	builtins -> struct_literal [label="arg #1"]
-	struct_literal -> builtins_13 [label="arg #0"]
+	struct_literal -> variable [label="arg #0"]
 	struct_literal -> number_literal [label="arg #1"]
 	contract -> getShares [label="function"]
 	getShares -> returns [label="returns"]
 	getShares -> var_decl [label="body"]
 	var_decl -> alloc_array [label="init"]
 	alloc_array -> array_length [label="length"]
-	array_length -> storage_var_20 [label="array"]
-	var_decl -> var_decl_21 [label="next"]
-	var_decl_21 -> alloc_array_22 [label="init"]
-	alloc_array_22 -> array_length_23 [label="length"]
-	array_length_23 -> storage_var_24 [label="array"]
-	var_decl_21 -> for [label="next"]
-	for -> var_decl_26 [label="init"]
-	var_decl_26 -> number_literal_27 [label="init"]
+	array_length -> storage_var_21 [label="array"]
+	var_decl -> var_decl_22 [label="next"]
+	var_decl_22 -> alloc_array_23 [label="init"]
+	alloc_array_23 -> array_length_24 [label="length"]
+	array_length_24 -> storage_var_25 [label="array"]
+	var_decl_22 -> for [label="next"]
+	for -> var_decl_27 [label="init"]
+	var_decl_27 -> number_literal_28 [label="init"]
 	for -> less [label="cond"]
-	less -> variable [label="left"]
+	less -> variable_30 [label="left"]
 	less -> zero_ext [label="right"]
-	zero_ext -> array_length_31 [label="expr"]
-	array_length_31 -> storage_var_32 [label="array"]
-	for -> expr_33 [label="next"]
-	expr_33 -> post_increment [label="expr"]
-	post_increment -> variable_35 [label="expr"]
-	for -> expr_36 [label="body"]
-	expr_36 -> assign [label="expr"]
+	zero_ext -> array_length_32 [label="expr"]
+	array_length_32 -> storage_var_33 [label="array"]
+	for -> expr_34 [label="next"]
+	expr_34 -> post_increment [label="expr"]
+	post_increment -> variable_36 [label="expr"]
+	for -> expr_37 [label="body"]
+	expr_37 -> assign [label="expr"]
 	assign -> subscript [label="left"]
-	subscript -> variable_39 [label="array"]
-	subscript -> variable_40 [label="index"]
+	subscript -> variable_40 [label="array"]
+	subscript -> variable_41 [label="index"]
 	assign -> cast [label="right"]
 	cast -> storage_load [label="expr"]
 	storage_load -> structmember [label="expr"]
-	structmember -> subscript_44 [label="var"]
-	subscript_44 -> storage_var_45 [label="array"]
-	subscript_44 -> variable_46 [label="index"]
-	expr_36 -> expr_47 [label="next"]
-	expr_47 -> assign_48 [label="expr"]
-	assign_48 -> subscript_49 [label="left"]
-	subscript_49 -> variable_50 [label="array"]
-	subscript_49 -> variable_51 [label="index"]
-	assign_48 -> storage_load_52 [label="right"]
-	storage_load_52 -> structmember_53 [label="expr"]
-	structmember_53 -> subscript_54 [label="var"]
-	subscript_54 -> storage_var_55 [label="array"]
-	subscript_54 -> variable_56 [label="index"]
+	structmember -> subscript_45 [label="var"]
+	subscript_45 -> storage_var_46 [label="array"]
+	subscript_45 -> variable_47 [label="index"]
+	expr_37 -> expr_48 [label="next"]
+	expr_48 -> assign_49 [label="expr"]
+	assign_49 -> subscript_50 [label="left"]
+	subscript_50 -> variable_51 [label="array"]
+	subscript_50 -> variable_52 [label="index"]
+	assign_49 -> storage_load_53 [label="right"]
+	storage_load_53 -> structmember_54 [label="expr"]
+	structmember_54 -> subscript_55 [label="var"]
+	subscript_55 -> storage_var_56 [label="array"]
+	subscript_55 -> variable_57 [label="index"]
 	for -> return [label="next"]
 	return -> list [label="expr"]
-	list -> variable_59 [label="entry #0"]
-	list -> variable_60 [label="entry #1"]
+	list -> variable_60 [label="entry #0"]
+	list -> variable_61 [label="entry #1"]
 	contract -> _senderIsAShareOwner [label="function"]
-	_senderIsAShareOwner -> returns_62 [label="returns"]
-	_senderIsAShareOwner -> for_63 [label="body"]
-	for_63 -> var_decl_64 [label="init"]
-	var_decl_64 -> number_literal_65 [label="init"]
-	for_63 -> less_66 [label="cond"]
-	less_66 -> variable_67 [label="left"]
-	less_66 -> zero_ext_68 [label="right"]
-	zero_ext_68 -> array_length_69 [label="expr"]
-	array_length_69 -> storage_var_70 [label="array"]
-	for_63 -> expr_71 [label="next"]
-	expr_71 -> post_increment_72 [label="expr"]
-	post_increment_72 -> variable_73 [label="expr"]
-	for_63 -> if [label="body"]
+	_senderIsAShareOwner -> parameters_63 [label="parameters"]
+	_senderIsAShareOwner -> returns_64 [label="returns"]
+	_senderIsAShareOwner -> for_65 [label="body"]
+	for_65 -> var_decl_66 [label="init"]
+	var_decl_66 -> number_literal_67 [label="init"]
+	for_65 -> less_68 [label="cond"]
+	less_68 -> variable_69 [label="left"]
+	less_68 -> zero_ext_70 [label="right"]
+	zero_ext_70 -> array_length_71 [label="expr"]
+	array_length_71 -> storage_var_72 [label="array"]
+	for_65 -> expr_73 [label="next"]
+	expr_73 -> post_increment_74 [label="expr"]
+	post_increment_74 -> variable_75 [label="expr"]
+	for_65 -> if [label="body"]
 	if -> equal [label="cond"]
-	equal -> storage_load_76 [label="left"]
-	storage_load_76 -> structmember_77 [label="expr"]
-	structmember_77 -> subscript_78 [label="var"]
-	subscript_78 -> storage_var_79 [label="array"]
-	subscript_78 -> variable_80 [label="index"]
-	equal -> builtins_81 [label="right"]
-	if -> return_82 [label="then"]
-	return_82 -> bool_literal [label="expr"]
-	for_63 -> return_84 [label="next"]
-	return_84 -> bool_literal_85 [label="expr"]
+	equal -> cast_78 [label="left"]
+	cast_78 -> storage_load_79 [label="expr"]
+	storage_load_79 -> structmember_80 [label="expr"]
+	structmember_80 -> subscript_81 [label="var"]
+	subscript_81 -> storage_var_82 [label="array"]
+	subscript_81 -> variable_83 [label="index"]
+	equal -> variable_84 [label="right"]
+	if -> return_85 [label="then"]
+	return_85 -> bool_literal [label="expr"]
+	for_65 -> return_87 [label="next"]
+	return_87 -> bool_literal_88 [label="expr"]
 	contract -> withdraw [label="function"]
-	withdraw -> tags_87 [label="tags"]
-	withdraw -> expr_88 [label="body"]
-	expr_88 -> builtins_89 [label="expr"]
-	builtins_89 -> call_internal_function [label="arg #0"]
+	withdraw -> tags_90 [label="tags"]
+	withdraw -> parameters_91 [label="parameters"]
+	withdraw -> expr_92 [label="body"]
+	expr_92 -> builtins_93 [label="expr"]
+	builtins_93 -> call_internal_function [label="arg #0"]
 	call_internal_function -> internal_function [label="function"]
-	builtins_89 -> alloc_array_92 [label="arg #1"]
-	alloc_array_92 -> number_literal_93 [label="length"]
-	expr_88 -> var_decl_94 [label="next"]
-	var_decl_94 -> sign_ext [label="init"]
-	sign_ext -> builtins_96 [label="expr"]
-	builtins_96 -> cast_97 [label="arg #0"]
-	cast_97 -> builtins_98 [label="expr"]
-	var_decl_94 -> expr_99 [label="next"]
-	expr_99 -> builtins_100 [label="expr"]
-	builtins_100 -> more [label="arg #0"]
-	more -> variable_102 [label="left"]
-	more -> number_literal_103 [label="right"]
-	builtins_100 -> alloc_array_104 [label="arg #1"]
-	alloc_array_104 -> number_literal_105 [label="length"]
-	expr_99 -> for_106 [label="next"]
-	for_106 -> var_decl_107 [label="init"]
-	var_decl_107 -> number_literal_108 [label="init"]
-	for_106 -> less_109 [label="cond"]
-	less_109 -> variable_110 [label="left"]
-	less_109 -> zero_ext_111 [label="right"]
-	zero_ext_111 -> array_length_112 [label="expr"]
-	array_length_112 -> storage_var_113 [label="array"]
-	for_106 -> expr_114 [label="next"]
-	expr_114 -> post_increment_115 [label="expr"]
-	post_increment_115 -> variable_116 [label="expr"]
-	for_106 -> var_decl_117 [label="body"]
-	var_decl_117 -> divide [label="init"]
+	call_internal_function -> variable_96 [label="arg #0"]
+	builtins_93 -> alloc_array_97 [label="arg #1"]
+	alloc_array_97 -> number_literal_98 [label="length"]
+	expr_92 -> var_decl_99 [label="next"]
+	var_decl_99 -> sign_ext [label="init"]
+	sign_ext -> builtins_101 [label="expr"]
+	builtins_101 -> cast_102 [label="arg #0"]
+	cast_102 -> builtins_103 [label="expr"]
+	var_decl_99 -> expr_104 [label="next"]
+	expr_104 -> builtins_105 [label="expr"]
+	builtins_105 -> more [label="arg #0"]
+	more -> variable_107 [label="left"]
+	more -> number_literal_108 [label="right"]
+	builtins_105 -> alloc_array_109 [label="arg #1"]
+	alloc_array_109 -> number_literal_110 [label="length"]
+	expr_104 -> for_111 [label="next"]
+	for_111 -> var_decl_112 [label="init"]
+	var_decl_112 -> number_literal_113 [label="init"]
+	for_111 -> less_114 [label="cond"]
+	less_114 -> variable_115 [label="left"]
+	less_114 -> zero_ext_116 [label="right"]
+	zero_ext_116 -> array_length_117 [label="expr"]
+	array_length_117 -> storage_var_118 [label="array"]
+	for_111 -> expr_119 [label="next"]
+	expr_119 -> post_increment_120 [label="expr"]
+	post_increment_120 -> variable_121 [label="expr"]
+	for_111 -> var_decl_122 [label="body"]
+	var_decl_122 -> divide [label="init"]
 	divide -> multiply [label="left"]
-	multiply -> variable_120 [label="left"]
-	multiply -> storage_load_121 [label="right"]
-	storage_load_121 -> structmember_122 [label="expr"]
-	structmember_122 -> subscript_123 [label="var"]
-	subscript_123 -> storage_var_124 [label="array"]
-	subscript_123 -> variable_125 [label="index"]
-	divide -> number_literal_126 [label="right"]
-	var_decl_117 -> expr_127 [label="next"]
-	expr_127 -> builtins_128 [label="expr"]
-	builtins_128 -> storage_load_129 [label="arg #0"]
-	storage_load_129 -> structmember_130 [label="expr"]
-	structmember_130 -> subscript_131 [label="var"]
-	subscript_131 -> storage_var_132 [label="array"]
-	subscript_131 -> variable_133 [label="index"]
-	builtins_128 -> cast_134 [label="arg #1"]
-	cast_134 -> trunc [label="expr"]
-	trunc -> variable_136 [label="expr"]
-	expr_127 -> emit [label="next"]
-	emit -> cast_138 [label="arg #0"]
-	cast_138 -> storage_load_139 [label="expr"]
-	storage_load_139 -> structmember_140 [label="expr"]
-	structmember_140 -> subscript_141 [label="var"]
-	subscript_141 -> storage_var_142 [label="array"]
-	subscript_141 -> variable_143 [label="index"]
-	emit -> variable_144 [label="arg #1"]
-	emit -> variable_145 [label="arg #2"]
-	for_106 -> if_146 [label="next"]
-	if_146 -> more_147 [label="cond"]
-	more_147 -> cast_148 [label="left"]
-	cast_148 -> builtins_149 [label="expr"]
-	builtins_149 -> cast_150 [label="arg #0"]
-	cast_150 -> builtins_151 [label="expr"]
-	more_147 -> number_literal_152 [label="right"]
-	if_146 -> expr_153 [label="then"]
-	expr_153 -> builtins_154 [label="expr"]
-	builtins_154 -> builtins_155 [label="arg #0"]
-	builtins_154 -> builtins_156 [label="arg #1"]
-	builtins_156 -> cast_157 [label="arg #0"]
-	cast_157 -> builtins_158 [label="expr"]
+	multiply -> variable_125 [label="left"]
+	multiply -> storage_load_126 [label="right"]
+	storage_load_126 -> structmember_127 [label="expr"]
+	structmember_127 -> subscript_128 [label="var"]
+	subscript_128 -> storage_var_129 [label="array"]
+	subscript_128 -> variable_130 [label="index"]
+	divide -> number_literal_131 [label="right"]
+	var_decl_122 -> expr_132 [label="next"]
+	expr_132 -> builtins_133 [label="expr"]
+	builtins_133 -> storage_load_134 [label="arg #0"]
+	storage_load_134 -> structmember_135 [label="expr"]
+	structmember_135 -> subscript_136 [label="var"]
+	subscript_136 -> storage_var_137 [label="array"]
+	subscript_136 -> variable_138 [label="index"]
+	builtins_133 -> cast_139 [label="arg #1"]
+	cast_139 -> trunc [label="expr"]
+	trunc -> variable_141 [label="expr"]
+	expr_132 -> emit [label="next"]
+	emit -> cast_143 [label="arg #0"]
+	cast_143 -> storage_load_144 [label="expr"]
+	storage_load_144 -> structmember_145 [label="expr"]
+	structmember_145 -> subscript_146 [label="var"]
+	subscript_146 -> storage_var_147 [label="array"]
+	subscript_146 -> variable_148 [label="index"]
+	emit -> variable_149 [label="arg #1"]
+	emit -> variable_150 [label="arg #2"]
+	for_111 -> if_151 [label="next"]
+	if_151 -> more_152 [label="cond"]
+	more_152 -> cast_153 [label="left"]
+	cast_153 -> builtins_154 [label="expr"]
+	builtins_154 -> cast_155 [label="arg #0"]
+	cast_155 -> builtins_156 [label="expr"]
+	more_152 -> number_literal_157 [label="right"]
+	if_151 -> expr_158 [label="then"]
+	expr_158 -> builtins_159 [label="expr"]
+	builtins_159 -> cast_160 [label="arg #0"]
+	cast_160 -> variable_161 [label="expr"]
+	builtins_159 -> builtins_162 [label="arg #1"]
+	builtins_162 -> cast_163 [label="arg #0"]
+	cast_163 -> builtins_164 [label="expr"]
 	diagnostics -> diagnostic [label="Debug"]
-	diagnostics -> diagnostic_161 [label="Debug"]
+	diagnostics -> diagnostic_167 [label="Debug"]
 }

tests/contract_testcases/solana/issues678.sol

@@ -12,8 +12,8 @@ contract Shares {
     Share[] private _shares;
 
     /// @notice Create the shares object that gives the shares to every body
-    constructor() {
-        _shares.push(Share(msg.sender, 1000));
+    constructor(address payable sender) {
+        _shares.push(Share(sender, 1000));
     }
 
     function getShares() external view returns(address[] memory, uint[] memory) {
@@ -26,9 +26,9 @@ contract Shares {
         return (retAddress, retShare);
     }
 
-    function _senderIsAShareOwner() private view returns (bool) {
+    function _senderIsAShareOwner(address sender) private view returns (bool) {
         for (uint i = 0; i < _shares.length; i++) {
-            if (_shares[i].shareOwner == msg.sender) {
+            if (_shares[i].shareOwner == sender) {
                 return true;
             }
         }
@@ -38,8 +38,8 @@ contract Shares {
     /**
     ** @dev Allow a share owner to retrieve his money. It empty the money contained inside of the smart contract to give it to owners.
      */
-    function withdraw() external {
-        require(_senderIsAShareOwner(), "You can't withdraw if you are not a share owner");
+    function withdraw(address sender) external {
+        require(_senderIsAShareOwner(sender), "You can't withdraw if you are not a share owner");
         uint curr_balance = address(this).balance;
         require(curr_balance > 0, "There is nothing to withdraw");
         for (uint i = 0; i < _shares.length; i++) {
@@ -50,7 +50,7 @@ contract Shares {
         if (address(this).balance > 0) {
             // Send the remaining money to the one who withdraw so there is nothing left on
             // the contract
-            payable(msg.sender).transfer(address(this).balance);
+            payable(sender).transfer(address(this).balance);
         }
     }
 }

tests/contract_testcases/solana/mapping_deletion.sol

@@ -19,7 +19,7 @@ contract DeleteTest {
     mapping(uint => savedTest) example2;
 
     function addData() public  {
-        data_struct dt = data_struct({addr1: address(this), addr2: msg.sender});
+        data_struct dt = data_struct({addr1: address(this), addr2: tx.program_id});
         uint id = 1;
         example[id] = dt;
         savedTest tt = new savedTest(4);
@@ -31,7 +31,7 @@ contract DeleteTest {
         delete example[id];
         //delete example2[id];
     }
-    
+
     function get() public view returns (data_struct calldata) {
         uint id = 1;
         return example[id];

tests/contract_testcases/solana/type_decl_import.dot

@@ -4,24 +4,25 @@ strict digraph "tests/contract_testcases/solana/type_decl_import.sol" {
 	contract [label="contract d\ntests/contract_testcases/solana/type_decl_import.sol:3:1-10:2"]
 	f [label="function f\ncontract: d\ntests/contract_testcases/solana/type_decl_import.sol:4:2-28\nsignature f(bytes32)\nvisibility public\nmutability nonpayable"]
 	parameters [label="parameters\ncontract x c"]
-	var_decl [label="variable decl usertype Addr a\ntests/contract_testcases/solana/type_decl_import.sol:5:3-41"]
-	builtins [label="builtin UserTypeWrap\ntests/contract_testcases/solana/type_decl_import.sol:5:16-41"]
-	builtins_9 [label="builtin Sender\ntests/contract_testcases/solana/type_decl_import.sol:5:30-40"]
-	var_decl_10 [label="variable decl usertype x.Binary b\ntests/contract_testcases/solana/type_decl_import.sol:6:3-44"]
-	builtins_11 [label="builtin UserTypeWrap\ntests/contract_testcases/solana/type_decl_import.sol:6:20-44"]
+	var_decl [label="variable decl usertype Addr a\ntests/contract_testcases/solana/type_decl_import.sol:5:3-44"]
+	builtins [label="builtin UserTypeWrap\ntests/contract_testcases/solana/type_decl_import.sol:5:16-44"]
+	cast [label="cast address payable\ntests/contract_testcases/solana/type_decl_import.sol:5:30-43"]
+	builtins_10 [label="builtin GetAddress\ntests/contract_testcases/solana/type_decl_import.sol:5:38-42"]
+	var_decl_11 [label="variable decl usertype x.Binary b\ntests/contract_testcases/solana/type_decl_import.sol:6:3-44"]
+	builtins_12 [label="builtin UserTypeWrap\ntests/contract_testcases/solana/type_decl_import.sol:6:20-44"]
 	bool_literal [label="bool literal: false\ntests/contract_testcases/solana/type_decl_import.sol:6:38-43"]
 	expr [label="expression\ntests/contract_testcases/solana/type_decl_import.sol:8:3-12"]
 	call_external_function [label="call external function\ntests/contract_testcases/solana/type_decl_import.sol:8:3-12"]
 	external_function [label="function(usertype Addr,usertype x.Binary) external returns (void)\nx.f\ntests/contract_testcases/solana/type_decl_import.sol:8:3-12"]
 	variable [label="variable: c\ncontract x\ntests/contract_testcases/solana/type_decl_import.sol:8:3-4"]
-	variable_17 [label="variable: a\nusertype Addr\ntests/contract_testcases/solana/type_decl_import.sol:8:7-8"]
-	variable_18 [label="variable: b\nusertype x.Binary\ntests/contract_testcases/solana/type_decl_import.sol:8:10-11"]
-	contract_19 [label="contract x\ntests/contract_testcases/solana/type_decl.sol:4:1-8:2"]
-	f_20 [label="function f\ncontract: x\ntests/contract_testcases/solana/type_decl.sol:7:2-33\nsignature f(bytes32,bool)\nvisibility public\nmutability nonpayable"]
-	parameters_21 [label="parameters\nusertype Addr \nusertype x.Binary "]
+	variable_18 [label="variable: a\nusertype Addr\ntests/contract_testcases/solana/type_decl_import.sol:8:7-8"]
+	variable_19 [label="variable: b\nusertype x.Binary\ntests/contract_testcases/solana/type_decl_import.sol:8:10-11"]
+	contract_20 [label="contract x\ntests/contract_testcases/solana/type_decl.sol:4:1-8:2"]
+	f_21 [label="function f\ncontract: x\ntests/contract_testcases/solana/type_decl.sol:7:2-33\nsignature f(bytes32,bool)\nvisibility public\nmutability nonpayable"]
+	parameters_22 [label="parameters\nusertype Addr \nusertype x.Binary "]
 	diagnostic [label="found contract 'd'\nlevel Debug\ntests/contract_testcases/solana/type_decl_import.sol:3:1-10:2"]
-	diagnostic_24 [label="found contract 'x'\nlevel Debug\ntests/contract_testcases/solana/type_decl.sol:4:1-8:2"]
-	diagnostic_25 [label="function can be declared 'pure'\nlevel Warning\ntests/contract_testcases/solana/type_decl.sol:7:2-33"]
+	diagnostic_25 [label="found contract 'x'\nlevel Debug\ntests/contract_testcases/solana/type_decl.sol:4:1-8:2"]
+	diagnostic_26 [label="function can be declared 'pure'\nlevel Warning\ntests/contract_testcases/solana/type_decl.sol:7:2-33"]
 	types -> Addr
 	types -> Binary
 	contracts -> contract
@@ -29,20 +30,21 @@ strict digraph "tests/contract_testcases/solana/type_decl_import.sol" {
 	f -> parameters [label="parameters"]
 	f -> var_decl [label="body"]
 	var_decl -> builtins [label="init"]
-	builtins -> builtins_9 [label="arg #0"]
-	var_decl -> var_decl_10 [label="next"]
-	var_decl_10 -> builtins_11 [label="init"]
-	builtins_11 -> bool_literal [label="arg #0"]
-	var_decl_10 -> expr [label="next"]
+	builtins -> cast [label="arg #0"]
+	cast -> builtins_10 [label="expr"]
+	var_decl -> var_decl_11 [label="next"]
+	var_decl_11 -> builtins_12 [label="init"]
+	builtins_12 -> bool_literal [label="arg #0"]
+	var_decl_11 -> expr [label="next"]
 	expr -> call_external_function [label="expr"]
 	call_external_function -> external_function [label="function"]
 	external_function -> variable [label="address"]
-	call_external_function -> variable_17 [label="arg #0"]
-	call_external_function -> variable_18 [label="arg #1"]
-	contracts -> contract_19
-	contract_19 -> f_20 [label="function"]
-	f_20 -> parameters_21 [label="parameters"]
+	call_external_function -> variable_18 [label="arg #0"]
+	call_external_function -> variable_19 [label="arg #1"]
+	contracts -> contract_20
+	contract_20 -> f_21 [label="function"]
+	f_21 -> parameters_22 [label="parameters"]
 	diagnostics -> diagnostic [label="Debug"]
-	diagnostics -> diagnostic_24 [label="Debug"]
-	diagnostics -> diagnostic_25 [label="Warning"]
+	diagnostics -> diagnostic_25 [label="Debug"]
+	diagnostics -> diagnostic_26 [label="Warning"]
 }

tests/contract_testcases/solana/type_decl_import.sol

@@ -2,7 +2,7 @@ import "type_decl.sol" as IMP;
 
 contract d {
 	function f(IMP.x c) public {
-		IMP.Addr a = IMP.Addr.wrap(msg.sender);
+		IMP.Addr a = IMP.Addr.wrap(payable(this));
 		IMP.x.Binary b = IMP.x.Binary.wrap(false);
 
 		c.f(a, b);

tests/contract_testcases/solana/doccomments_everywhere.dot → tests/contract_testcases/substrate/doccomments_everywhere.dot

@@ -1,13 +1,13 @@
-strict digraph "tests/contract_testcases/solana/doccomments_everywhere.sol" {
-	MintProperty [label="name:MintProperty\ncontract: 0\ntests/contract_testcases/solana/doccomments_everywhere.sol:15:9-21\nfield name:id ty:uint256 indexed:no"]
-	contract [label="contract Property\ntests/contract_testcases/solana/doccomments_everywhere.sol:5:1-99:2"]
+strict digraph "tests/contract_testcases/substrate/doccomments_everywhere.sol" {
+	MintProperty [label="name:MintProperty\ncontract: 0\ntests/contract_testcases/substrate/doccomments_everywhere.sol:15:9-21\nfield name:id ty:uint256 indexed:no"]
+	contract [label="contract Property\ntests/contract_testcases/substrate/doccomments_everywhere.sol:5:1-99:2"]
 	tags [label="author: Max Campbell (https://github.com/maxall41), RafaCypherpunk (https://github.com/RafaCypherpunk)"]
-	var [label="variable pricePerShare_\nvisibility public\ntests/contract_testcases/solana/doccomments_everywhere.sol:9:3-52"]
-	var_6 [label="variable valueLocked_\nvisibility public\ntests/contract_testcases/solana/doccomments_everywhere.sol:10:3-50"]
-	var_7 [label="variable tokenDeployers_\nvisibility public\ntests/contract_testcases/solana/doccomments_everywhere.sol:11:3-53"]
-	var_8 [label="variable sellingTokens_\nvisibility public\ntests/contract_testcases/solana/doccomments_everywhere.sol:12:3-52"]
-	var_9 [label="variable buyingTokens_\nvisibility public\ntests/contract_testcases/solana/doccomments_everywhere.sol:13:3-51"]
-	pricePerShare_ [label="function pricePerShare_\ncontract: Property\ntests/contract_testcases/solana/doccomments_everywhere.sol:9:38-52\nsignature pricePerShare_(uint256)\nvisibility public\nmutability view"]
+	var [label="variable pricePerShare_\nvisibility public\ntests/contract_testcases/substrate/doccomments_everywhere.sol:9:3-52"]
+	var_6 [label="variable valueLocked_\nvisibility public\ntests/contract_testcases/substrate/doccomments_everywhere.sol:10:3-50"]
+	var_7 [label="variable tokenDeployers_\nvisibility public\ntests/contract_testcases/substrate/doccomments_everywhere.sol:11:3-53"]
+	var_8 [label="variable sellingTokens_\nvisibility public\ntests/contract_testcases/substrate/doccomments_everywhere.sol:12:3-52"]
+	var_9 [label="variable buyingTokens_\nvisibility public\ntests/contract_testcases/substrate/doccomments_everywhere.sol:13:3-51"]
+	pricePerShare_ [label="function pricePerShare_\ncontract: Property\ntests/contract_testcases/substrate/doccomments_everywhere.sol:9:38-52\nsignature pricePerShare_(uint256)\nvisibility public\nmutability view"]
 	parameters [label="parameters\nuint256 "]
 	returns [label="returns\nuint256 "]
 	return [label="return\nimplicit"]
@@ -15,7 +15,7 @@ strict digraph "tests/contract_testcases/solana/doccomments_everywhere.sol" {
 	subscript [label="subscript mapping(uint256 => uint256) storage\nimplicit"]
 	storage_var [label="storage variable\nProperty.pricePerShare_\nmapping(uint256 => uint256) storage\nimplicit"]
 	variable [label="variable: \nuint256\nimplicit"]
-	valueLocked_ [label="function valueLocked_\ncontract: Property\ntests/contract_testcases/solana/doccomments_everywhere.sol:10:38-50\nsignature valueLocked_(bytes32)\nvisibility public\nmutability view"]
+	valueLocked_ [label="function valueLocked_\ncontract: Property\ntests/contract_testcases/substrate/doccomments_everywhere.sol:10:38-50\nsignature valueLocked_(address)\nvisibility public\nmutability view"]
 	parameters_19 [label="parameters\naddress "]
 	returns_20 [label="returns\nuint256 "]
 	return_21 [label="return\nimplicit"]
@@ -23,7 +23,7 @@ strict digraph "tests/contract_testcases/solana/doccomments_everywhere.sol" {
 	subscript_23 [label="subscript mapping(address => uint256) storage\nimplicit"]
 	storage_var_24 [label="storage variable\nProperty.valueLocked_\nmapping(address => uint256) storage\nimplicit"]
 	variable_25 [label="variable: \naddress\nimplicit"]
-	tokenDeployers_ [label="function tokenDeployers_\ncontract: Property\ntests/contract_testcases/solana/doccomments_everywhere.sol:11:38-53\nsignature tokenDeployers_(uint256)\nvisibility public\nmutability view"]
+	tokenDeployers_ [label="function tokenDeployers_\ncontract: Property\ntests/contract_testcases/substrate/doccomments_everywhere.sol:11:38-53\nsignature tokenDeployers_(uint256)\nvisibility public\nmutability view"]
 	parameters_27 [label="parameters\nuint256 "]
 	returns_28 [label="returns\naddress "]
 	return_29 [label="return\nimplicit"]
@@ -31,7 +31,7 @@ strict digraph "tests/contract_testcases/solana/doccomments_everywhere.sol" {
 	subscript_31 [label="subscript mapping(uint256 => address) storage\nimplicit"]
 	storage_var_32 [label="storage variable\nProperty.tokenDeployers_\nmapping(uint256 => address) storage\nimplicit"]
 	variable_33 [label="variable: \nuint256\nimplicit"]
-	sellingTokens_ [label="function sellingTokens_\ncontract: Property\ntests/contract_testcases/solana/doccomments_everywhere.sol:12:38-52\nsignature sellingTokens_(uint256)\nvisibility public\nmutability view"]
+	sellingTokens_ [label="function sellingTokens_\ncontract: Property\ntests/contract_testcases/substrate/doccomments_everywhere.sol:12:38-52\nsignature sellingTokens_(uint256)\nvisibility public\nmutability view"]
 	parameters_35 [label="parameters\nuint256 "]
 	returns_36 [label="returns\nuint256 "]
 	return_37 [label="return\nimplicit"]
@@ -39,7 +39,7 @@ strict digraph "tests/contract_testcases/solana/doccomments_everywhere.sol" {
 	subscript_39 [label="subscript mapping(uint256 => uint256) storage\nimplicit"]
 	storage_var_40 [label="storage variable\nProperty.sellingTokens_\nmapping(uint256 => uint256) storage\nimplicit"]
 	variable_41 [label="variable: \nuint256\nimplicit"]
-	buyingTokens_ [label="function buyingTokens_\ncontract: Property\ntests/contract_testcases/solana/doccomments_everywhere.sol:13:38-51\nsignature buyingTokens_(uint256)\nvisibility public\nmutability view"]
+	buyingTokens_ [label="function buyingTokens_\ncontract: Property\ntests/contract_testcases/substrate/doccomments_everywhere.sol:13:38-51\nsignature buyingTokens_(uint256)\nvisibility public\nmutability view"]
 	parameters_43 [label="parameters\nuint256 "]
 	returns_44 [label="returns\nuint256 "]
 	return_45 [label="return\nimplicit"]
@@ -47,94 +47,92 @@ strict digraph "tests/contract_testcases/solana/doccomments_everywhere.sol" {
 	subscript_47 [label="subscript mapping(uint256 => uint256) storage\nimplicit"]
 	storage_var_48 [label="storage variable\nProperty.buyingTokens_\nmapping(uint256 => uint256) storage\nimplicit"]
 	variable_49 [label="variable: \nuint256\nimplicit"]
-	node_50 [label="constructor \ncontract: Property\ntests/contract_testcases/solana/doccomments_everywhere.sol:17:3-76\nsignature ()\nvisibility public\nmutability nonpayable"]
-	node_51 [label="receive \ncontract: Property\ntests/contract_testcases/solana/doccomments_everywhere.sol:19:3-29\nmutability payable"]
-	expr [label="expression\ntests/contract_testcases/solana/doccomments_everywhere.sol:20:5-68"]
-	assign [label="assign\nuint256 storage\ntests/contract_testcases/solana/doccomments_everywhere.sol:20:5-68"]
-	subscript_54 [label="subscript mapping(address => uint256) storage\ntests/contract_testcases/solana/doccomments_everywhere.sol:20:5-29"]
-	storage_var_55 [label="storage variable\nProperty.valueLocked_\nmapping(address => uint256) storage\ntests/contract_testcases/solana/doccomments_everywhere.sol:20:5-17"]
-	cast [label="cast address\ntests/contract_testcases/solana/doccomments_everywhere.sol:20:18-28"]
-	builtins [label="builtin Sender\ntests/contract_testcases/solana/doccomments_everywhere.sol:20:18-28"]
-	add [label="add\nuint256\ntests/contract_testcases/solana/doccomments_everywhere.sol:20:32-68"]
-	storage_load_59 [label="storage load uint256\ntests/contract_testcases/solana/doccomments_everywhere.sol:20:32-56"]
-	subscript_60 [label="subscript mapping(address => uint256) storage\ntests/contract_testcases/solana/doccomments_everywhere.sol:20:32-56"]
-	storage_var_61 [label="storage variable\nProperty.valueLocked_\nmapping(address => uint256) storage\ntests/contract_testcases/solana/doccomments_everywhere.sol:20:32-44"]
-	cast_62 [label="cast address\ntests/contract_testcases/solana/doccomments_everywhere.sol:20:45-55"]
-	builtins_63 [label="builtin Sender\ntests/contract_testcases/solana/doccomments_everywhere.sol:20:45-55"]
-	sign_ext [label="sign extend uint256\ntests/contract_testcases/solana/doccomments_everywhere.sol:20:59-68"]
-	builtins_65 [label="builtin Value\ntests/contract_testcases/solana/doccomments_everywhere.sol:20:59-68"]
-	mintProperty [label="function mintProperty\ncontract: Property\ntests/contract_testcases/solana/doccomments_everywhere.sol:23:3-27:11\nsignature mintProperty(uint256,uint256,uint256)\nvisibility public\nmutability nonpayable"]
+	new [label="constructor new\ncontract: Property\ntests/contract_testcases/substrate/doccomments_everywhere.sol:17:3-76\nsignature new()\nvisibility public\nmutability nonpayable"]
+	node_51 [label="receive \ncontract: Property\ntests/contract_testcases/substrate/doccomments_everywhere.sol:19:3-29\nmutability payable"]
+	expr [label="expression\ntests/contract_testcases/substrate/doccomments_everywhere.sol:20:5-68"]
+	assign [label="assign\nuint256 storage\ntests/contract_testcases/substrate/doccomments_everywhere.sol:20:5-68"]
+	subscript_54 [label="subscript mapping(address => uint256) storage\ntests/contract_testcases/substrate/doccomments_everywhere.sol:20:5-29"]
+	storage_var_55 [label="storage variable\nProperty.valueLocked_\nmapping(address => uint256) storage\ntests/contract_testcases/substrate/doccomments_everywhere.sol:20:5-17"]
+	cast [label="cast address\ntests/contract_testcases/substrate/doccomments_everywhere.sol:20:18-28"]
+	builtins [label="builtin Sender\ntests/contract_testcases/substrate/doccomments_everywhere.sol:20:18-28"]
+	add [label="add\nuint256\ntests/contract_testcases/substrate/doccomments_everywhere.sol:20:32-68"]
+	storage_load_59 [label="storage load uint256\ntests/contract_testcases/substrate/doccomments_everywhere.sol:20:32-56"]
+	subscript_60 [label="subscript mapping(address => uint256) storage\ntests/contract_testcases/substrate/doccomments_everywhere.sol:20:32-56"]
+	storage_var_61 [label="storage variable\nProperty.valueLocked_\nmapping(address => uint256) storage\ntests/contract_testcases/substrate/doccomments_everywhere.sol:20:32-44"]
+	cast_62 [label="cast address\ntests/contract_testcases/substrate/doccomments_everywhere.sol:20:45-55"]
+	builtins_63 [label="builtin Sender\ntests/contract_testcases/substrate/doccomments_everywhere.sol:20:45-55"]
+	sign_ext [label="sign extend uint256\ntests/contract_testcases/substrate/doccomments_everywhere.sol:20:59-68"]
+	builtins_65 [label="builtin Value\ntests/contract_testcases/substrate/doccomments_everywhere.sol:20:59-68"]
+	mintProperty [label="function mintProperty\ncontract: Property\ntests/contract_testcases/substrate/doccomments_everywhere.sol:23:3-27:11\nsignature mintProperty(uint256,uint256,uint256)\nvisibility public\nmutability nonpayable"]
 	parameters_67 [label="parameters\nuint256 _shares\nuint256 _pricePerShare\nuint256 _sharesForSale"]
-	getTokenOwner [label="function getTokenOwner\ncontract: Property\ntests/contract_testcases/solana/doccomments_everywhere.sol:37:3-76\nsignature getTokenOwner(uint256)\nvisibility public\nmutability view"]
+	getTokenOwner [label="function getTokenOwner\ncontract: Property\ntests/contract_testcases/substrate/doccomments_everywhere.sol:37:3-76\nsignature getTokenOwner(uint256)\nvisibility public\nmutability view"]
 	parameters_69 [label="parameters\nuint256 _id"]
 	returns_70 [label="returns\naddress payable "]
-	return_71 [label="return\ntests/contract_testcases/solana/doccomments_everywhere.sol:38:5-41"]
-	cast_72 [label="cast address payable\ntests/contract_testcases/solana/doccomments_everywhere.sol:38:12-41"]
-	storage_load_73 [label="storage load address\ntests/contract_testcases/solana/doccomments_everywhere.sol:38:12-41"]
-	subscript_74 [label="subscript mapping(uint256 => address) storage\ntests/contract_testcases/solana/doccomments_everywhere.sol:38:20-40"]
-	storage_var_75 [label="storage variable\nProperty.tokenDeployers_\nmapping(uint256 => address) storage\ntests/contract_testcases/solana/doccomments_everywhere.sol:38:20-35"]
-	variable_76 [label="variable: _id\nuint256\ntests/contract_testcases/solana/doccomments_everywhere.sol:38:36-39"]
-	getPricePerShare [label="function getPricePerShare\ncontract: Property\ntests/contract_testcases/solana/doccomments_everywhere.sol:41:3-71\nsignature getPricePerShare(uint256)\nvisibility public\nmutability view"]
+	return_71 [label="return\ntests/contract_testcases/substrate/doccomments_everywhere.sol:38:5-41"]
+	cast_72 [label="cast address payable\ntests/contract_testcases/substrate/doccomments_everywhere.sol:38:12-41"]
+	storage_load_73 [label="storage load address\ntests/contract_testcases/substrate/doccomments_everywhere.sol:38:12-41"]
+	subscript_74 [label="subscript mapping(uint256 => address) storage\ntests/contract_testcases/substrate/doccomments_everywhere.sol:38:20-40"]
+	storage_var_75 [label="storage variable\nProperty.tokenDeployers_\nmapping(uint256 => address) storage\ntests/contract_testcases/substrate/doccomments_everywhere.sol:38:20-35"]
+	variable_76 [label="variable: _id\nuint256\ntests/contract_testcases/substrate/doccomments_everywhere.sol:38:36-39"]
+	getPricePerShare [label="function getPricePerShare\ncontract: Property\ntests/contract_testcases/substrate/doccomments_everywhere.sol:41:3-71\nsignature getPricePerShare(uint256)\nvisibility public\nmutability view"]
 	parameters_78 [label="parameters\nuint256 _id"]
 	returns_79 [label="returns\nuint256 "]
-	return_80 [label="return\ntests/contract_testcases/solana/doccomments_everywhere.sol:42:5-31"]
-	storage_load_81 [label="storage load uint256\ntests/contract_testcases/solana/doccomments_everywhere.sol:42:5-31"]
-	subscript_82 [label="subscript mapping(uint256 => uint256) storage\ntests/contract_testcases/solana/doccomments_everywhere.sol:42:12-31"]
-	storage_var_83 [label="storage variable\nProperty.pricePerShare_\nmapping(uint256 => uint256) storage\ntests/contract_testcases/solana/doccomments_everywhere.sol:42:12-26"]
-	variable_84 [label="variable: _id\nuint256\ntests/contract_testcases/solana/doccomments_everywhere.sol:42:27-30"]
-	purchaseShares [label="function purchaseShares\ncontract: Property\ntests/contract_testcases/solana/doccomments_everywhere.sol:46:3-71\nsignature purchaseShares(uint256,uint256)\nvisibility public\nmutability payable"]
+	return_80 [label="return\ntests/contract_testcases/substrate/doccomments_everywhere.sol:42:5-31"]
+	storage_load_81 [label="storage load uint256\ntests/contract_testcases/substrate/doccomments_everywhere.sol:42:5-31"]
+	subscript_82 [label="subscript mapping(uint256 => uint256) storage\ntests/contract_testcases/substrate/doccomments_everywhere.sol:42:12-31"]
+	storage_var_83 [label="storage variable\nProperty.pricePerShare_\nmapping(uint256 => uint256) storage\ntests/contract_testcases/substrate/doccomments_everywhere.sol:42:12-26"]
+	variable_84 [label="variable: _id\nuint256\ntests/contract_testcases/substrate/doccomments_everywhere.sol:42:27-30"]
+	purchaseShares [label="function purchaseShares\ncontract: Property\ntests/contract_testcases/substrate/doccomments_everywhere.sol:46:3-71\nsignature purchaseShares(uint256,uint256)\nvisibility public\nmutability payable"]
 	tags_86 [label="dev: Used to purchase shares"]
 	parameters_87 [label="parameters\nuint256 _shares\nuint256 _id"]
-	setSellingShares [label="function setSellingShares\ncontract: Property\ntests/contract_testcases/solana/doccomments_everywhere.sol:67:3-74\nsignature setSellingShares(uint256,uint256)\nvisibility public\nmutability nonpayable"]
+	setSellingShares [label="function setSellingShares\ncontract: Property\ntests/contract_testcases/substrate/doccomments_everywhere.sol:67:3-74\nsignature setSellingShares(uint256,uint256)\nvisibility public\nmutability nonpayable"]
 	parameters_89 [label="parameters\nuint256 _newSharesToSell\nuint256 _id"]
-	expr_90 [label="expression\ntests/contract_testcases/solana/doccomments_everywhere.sol:68:5-73"]
-	builtins_91 [label="builtin Require\ntests/contract_testcases/solana/doccomments_everywhere.sol:68:5-12"]
-	equal [label="equal\ntests/contract_testcases/solana/doccomments_everywhere.sol:68:13-47"]
-	cast_93 [label="cast address\ntests/contract_testcases/solana/doccomments_everywhere.sol:68:13-23"]
-	builtins_94 [label="builtin Sender\ntests/contract_testcases/solana/doccomments_everywhere.sol:68:13-23"]
-	storage_load_95 [label="storage load address\ntests/contract_testcases/solana/doccomments_everywhere.sol:68:27-47"]
-	subscript_96 [label="subscript mapping(uint256 => address) storage\ntests/contract_testcases/solana/doccomments_everywhere.sol:68:27-47"]
-	storage_var_97 [label="storage variable\nProperty.tokenDeployers_\nmapping(uint256 => address) storage\ntests/contract_testcases/solana/doccomments_everywhere.sol:68:27-42"]
-	variable_98 [label="variable: _id\nuint256\ntests/contract_testcases/solana/doccomments_everywhere.sol:68:43-46"]
-	alloc_array [label="alloc array string\ninitializer: 596f7520617265206e6f7420746865206f776e6572\ntests/contract_testcases/solana/doccomments_everywhere.sol:68:49-72"]
-	number_literal [label="uint32 literal: 21\ntests/contract_testcases/solana/doccomments_everywhere.sol:68:49-72"]
-	expr_101 [label="expression\ntests/contract_testcases/solana/doccomments_everywhere.sol:69:5-43"]
-	assign_102 [label="assign\nuint256 storage\ntests/contract_testcases/solana/doccomments_everywhere.sol:69:5-43"]
-	subscript_103 [label="subscript mapping(uint256 => uint256) storage\ntests/contract_testcases/solana/doccomments_everywhere.sol:69:5-24"]
-	storage_var_104 [label="storage variable\nProperty.sellingTokens_\nmapping(uint256 => uint256) storage\ntests/contract_testcases/solana/doccomments_everywhere.sol:69:5-19"]
-	variable_105 [label="variable: _id\nuint256\ntests/contract_testcases/solana/doccomments_everywhere.sol:69:20-23"]
-	variable_106 [label="variable: _newSharesToSell\nuint256\ntests/contract_testcases/solana/doccomments_everywhere.sol:69:27-43"]
-	setBuyingShares [label="function setBuyingShares\ncontract: Property\ntests/contract_testcases/solana/doccomments_everywhere.sol:72:3-73\nsignature setBuyingShares(uint256,uint256)\nvisibility public\nmutability nonpayable"]
+	expr_90 [label="expression\ntests/contract_testcases/substrate/doccomments_everywhere.sol:68:5-73"]
+	builtins_91 [label="builtin Require\ntests/contract_testcases/substrate/doccomments_everywhere.sol:68:5-12"]
+	equal [label="equal\ntests/contract_testcases/substrate/doccomments_everywhere.sol:68:13-47"]
+	cast_93 [label="cast address\ntests/contract_testcases/substrate/doccomments_everywhere.sol:68:13-23"]
+	builtins_94 [label="builtin Sender\ntests/contract_testcases/substrate/doccomments_everywhere.sol:68:13-23"]
+	storage_load_95 [label="storage load address\ntests/contract_testcases/substrate/doccomments_everywhere.sol:68:27-47"]
+	subscript_96 [label="subscript mapping(uint256 => address) storage\ntests/contract_testcases/substrate/doccomments_everywhere.sol:68:27-47"]
+	storage_var_97 [label="storage variable\nProperty.tokenDeployers_\nmapping(uint256 => address) storage\ntests/contract_testcases/substrate/doccomments_everywhere.sol:68:27-42"]
+	variable_98 [label="variable: _id\nuint256\ntests/contract_testcases/substrate/doccomments_everywhere.sol:68:43-46"]
+	alloc_array [label="alloc array string\ninitializer: 596f7520617265206e6f7420746865206f776e6572\ntests/contract_testcases/substrate/doccomments_everywhere.sol:68:49-72"]
+	number_literal [label="uint32 literal: 21\ntests/contract_testcases/substrate/doccomments_everywhere.sol:68:49-72"]
+	expr_101 [label="expression\ntests/contract_testcases/substrate/doccomments_everywhere.sol:69:5-43"]
+	assign_102 [label="assign\nuint256 storage\ntests/contract_testcases/substrate/doccomments_everywhere.sol:69:5-43"]
+	subscript_103 [label="subscript mapping(uint256 => uint256) storage\ntests/contract_testcases/substrate/doccomments_everywhere.sol:69:5-24"]
+	storage_var_104 [label="storage variable\nProperty.sellingTokens_\nmapping(uint256 => uint256) storage\ntests/contract_testcases/substrate/doccomments_everywhere.sol:69:5-19"]
+	variable_105 [label="variable: _id\nuint256\ntests/contract_testcases/substrate/doccomments_everywhere.sol:69:20-23"]
+	variable_106 [label="variable: _newSharesToSell\nuint256\ntests/contract_testcases/substrate/doccomments_everywhere.sol:69:27-43"]
+	setBuyingShares [label="function setBuyingShares\ncontract: Property\ntests/contract_testcases/substrate/doccomments_everywhere.sol:72:3-73\nsignature setBuyingShares(uint256,uint256)\nvisibility public\nmutability nonpayable"]
 	parameters_108 [label="parameters\nuint256 _newSharesToSell\nuint256 _id"]
-	expr_109 [label="expression\ntests/contract_testcases/solana/doccomments_everywhere.sol:73:5-73"]
-	builtins_110 [label="builtin Require\ntests/contract_testcases/solana/doccomments_everywhere.sol:73:5-12"]
-	equal_111 [label="equal\ntests/contract_testcases/solana/doccomments_everywhere.sol:73:13-47"]
-	cast_112 [label="cast address\ntests/contract_testcases/solana/doccomments_everywhere.sol:73:13-23"]
-	builtins_113 [label="builtin Sender\ntests/contract_testcases/solana/doccomments_everywhere.sol:73:13-23"]
-	storage_load_114 [label="storage load address\ntests/contract_testcases/solana/doccomments_everywhere.sol:73:27-47"]
-	subscript_115 [label="subscript mapping(uint256 => address) storage\ntests/contract_testcases/solana/doccomments_everywhere.sol:73:27-47"]
-	storage_var_116 [label="storage variable\nProperty.tokenDeployers_\nmapping(uint256 => address) storage\ntests/contract_testcases/solana/doccomments_everywhere.sol:73:27-42"]
-	variable_117 [label="variable: _id\nuint256\ntests/contract_testcases/solana/doccomments_everywhere.sol:73:43-46"]
-	alloc_array_118 [label="alloc array string\ninitializer: 596f7520617265206e6f7420746865206f776e6572\ntests/contract_testcases/solana/doccomments_everywhere.sol:73:49-72"]
-	number_literal_119 [label="uint32 literal: 21\ntests/contract_testcases/solana/doccomments_everywhere.sol:73:49-72"]
-	expr_120 [label="expression\ntests/contract_testcases/solana/doccomments_everywhere.sol:74:5-42"]
-	assign_121 [label="assign\nuint256 storage\ntests/contract_testcases/solana/doccomments_everywhere.sol:74:5-42"]
-	subscript_122 [label="subscript mapping(uint256 => uint256) storage\ntests/contract_testcases/solana/doccomments_everywhere.sol:74:5-23"]
-	storage_var_123 [label="storage variable\nProperty.buyingTokens_\nmapping(uint256 => uint256) storage\ntests/contract_testcases/solana/doccomments_everywhere.sol:74:5-18"]
-	variable_124 [label="variable: _id\nuint256\ntests/contract_testcases/solana/doccomments_everywhere.sol:74:19-22"]
-	variable_125 [label="variable: _newSharesToSell\nuint256\ntests/contract_testcases/solana/doccomments_everywhere.sol:74:26-42"]
-	sellShares [label="function sellShares\ncontract: Property\ntests/contract_testcases/solana/doccomments_everywhere.sol:77:3-59\nsignature sellShares(uint256,uint256)\nvisibility public\nmutability nonpayable"]
+	expr_109 [label="expression\ntests/contract_testcases/substrate/doccomments_everywhere.sol:73:5-73"]
+	builtins_110 [label="builtin Require\ntests/contract_testcases/substrate/doccomments_everywhere.sol:73:5-12"]
+	equal_111 [label="equal\ntests/contract_testcases/substrate/doccomments_everywhere.sol:73:13-47"]
+	cast_112 [label="cast address\ntests/contract_testcases/substrate/doccomments_everywhere.sol:73:13-23"]
+	builtins_113 [label="builtin Sender\ntests/contract_testcases/substrate/doccomments_everywhere.sol:73:13-23"]
+	storage_load_114 [label="storage load address\ntests/contract_testcases/substrate/doccomments_everywhere.sol:73:27-47"]
+	subscript_115 [label="subscript mapping(uint256 => address) storage\ntests/contract_testcases/substrate/doccomments_everywhere.sol:73:27-47"]
+	storage_var_116 [label="storage variable\nProperty.tokenDeployers_\nmapping(uint256 => address) storage\ntests/contract_testcases/substrate/doccomments_everywhere.sol:73:27-42"]
+	variable_117 [label="variable: _id\nuint256\ntests/contract_testcases/substrate/doccomments_everywhere.sol:73:43-46"]
+	alloc_array_118 [label="alloc array string\ninitializer: 596f7520617265206e6f7420746865206f776e6572\ntests/contract_testcases/substrate/doccomments_everywhere.sol:73:49-72"]
+	number_literal_119 [label="uint32 literal: 21\ntests/contract_testcases/substrate/doccomments_everywhere.sol:73:49-72"]
+	expr_120 [label="expression\ntests/contract_testcases/substrate/doccomments_everywhere.sol:74:5-42"]
+	assign_121 [label="assign\nuint256 storage\ntests/contract_testcases/substrate/doccomments_everywhere.sol:74:5-42"]
+	subscript_122 [label="subscript mapping(uint256 => uint256) storage\ntests/contract_testcases/substrate/doccomments_everywhere.sol:74:5-23"]
+	storage_var_123 [label="storage variable\nProperty.buyingTokens_\nmapping(uint256 => uint256) storage\ntests/contract_testcases/substrate/doccomments_everywhere.sol:74:5-18"]
+	variable_124 [label="variable: _id\nuint256\ntests/contract_testcases/substrate/doccomments_everywhere.sol:74:19-22"]
+	variable_125 [label="variable: _newSharesToSell\nuint256\ntests/contract_testcases/substrate/doccomments_everywhere.sol:74:26-42"]
+	sellShares [label="function sellShares\ncontract: Property\ntests/contract_testcases/substrate/doccomments_everywhere.sol:77:3-59\nsignature sellShares(uint256,uint256)\nvisibility public\nmutability nonpayable"]
 	parameters_127 [label="parameters\nuint256 shares_\nuint256 _id"]
-	diagnostic [label="pragma 'solidity' is ignored\nlevel Debug\ntests/contract_testcases/solana/doccomments_everywhere.sol:1:1-24"]
-	diagnostic_130 [label="found contract 'Property'\nlevel Debug\ntests/contract_testcases/solana/doccomments_everywhere.sol:5:1-99:2"]
-	diagnostic_131 [label="'Counters' not found\nlevel Error\ntests/contract_testcases/solana/doccomments_everywhere.sol:6:22-30"]
-	diagnostic_132 [label="'Counters' not found\nlevel Error\ntests/contract_testcases/solana/doccomments_everywhere.sol:7:3-11"]
-	diagnostic_133 [label="'ERC1155' not found\nlevel Error\ntests/contract_testcases/solana/doccomments_everywhere.sol:17:17-24"]
-	diagnostic_134 [label="target solana does not support receive() functions, see https://solang.readthedocs.io/en/latest/language/functions.html#fallback-and-receive-function\nlevel Error\ntests/contract_testcases/solana/doccomments_everywhere.sol:19:3-29"]
-	diagnostic_135 [label="Solana Cross Program Invocation (CPI) cannot transfer native value. See https://solang.readthedocs.io/en/latest/language/functions.html#value_transfer\nlevel Error\ntests/contract_testcases/solana/doccomments_everywhere.sol:20:59-68"]
-	diagnostic_136 [label="'_tokenIds' not found\nlevel Error\ntests/contract_testcases/solana/doccomments_everywhere.sol:28:29-38"]
-	diagnostic_137 [label="cannot find overloaded function which matches signature\nlevel Error\ntests/contract_testcases/solana/doccomments_everywhere.sol:53:7-50"]
-	diagnostic_138 [label="cannot find overloaded function which matches signature\nlevel Error\ntests/contract_testcases/solana/doccomments_everywhere.sol:86:7-38"]
+	diagnostic [label="pragma 'solidity' is ignored\nlevel Debug\ntests/contract_testcases/substrate/doccomments_everywhere.sol:1:1-24"]
+	diagnostic_130 [label="found contract 'Property'\nlevel Debug\ntests/contract_testcases/substrate/doccomments_everywhere.sol:5:1-99:2"]
+	diagnostic_131 [label="'Counters' not found\nlevel Error\ntests/contract_testcases/substrate/doccomments_everywhere.sol:6:22-30"]
+	diagnostic_132 [label="'Counters' not found\nlevel Error\ntests/contract_testcases/substrate/doccomments_everywhere.sol:7:3-11"]
+	diagnostic_133 [label="'ERC1155' not found\nlevel Error\ntests/contract_testcases/substrate/doccomments_everywhere.sol:17:17-24"]
+	diagnostic_134 [label="'_tokenIds' not found\nlevel Error\ntests/contract_testcases/substrate/doccomments_everywhere.sol:28:29-38"]
+	diagnostic_135 [label="cannot find overloaded function which matches signature\nlevel Error\ntests/contract_testcases/substrate/doccomments_everywhere.sol:53:7-50"]
+	diagnostic_136 [label="cannot find overloaded function which matches signature\nlevel Error\ntests/contract_testcases/substrate/doccomments_everywhere.sol:86:7-38"]
 	events -> MintProperty
 	contracts -> contract
 	contract -> tags [label="tags"]
@@ -183,7 +181,7 @@ strict digraph "tests/contract_testcases/solana/doccomments_everywhere.sol" {
 	storage_load_46 -> subscript_47 [label="expr"]
 	subscript_47 -> storage_var_48 [label="array"]
 	subscript_47 -> variable_49 [label="index"]
-	contract -> node_50 [label="constructor"]
+	contract -> new [label="constructor"]
 	contract -> node_51 [label="receive"]
 	node_51 -> expr [label="body"]
 	expr -> assign [label="expr"]
@@ -269,6 +267,4 @@ strict digraph "tests/contract_testcases/solana/doccomments_everywhere.sol" {
 	diagnostics -> diagnostic_134 [label="Error"]
 	diagnostics -> diagnostic_135 [label="Error"]
 	diagnostics -> diagnostic_136 [label="Error"]
-	diagnostics -> diagnostic_137 [label="Error"]
-	diagnostics -> diagnostic_138 [label="Error"]
 }

tests/doc_examples.rs

@@ -100,6 +100,7 @@ fn substrate_general() {
 #[test]
 fn substrate_specific() {
     assert_compile("docs/examples/substrate/", Target::default_substrate());
+    assert_compile("examples/substrate/", Target::default_substrate());
 }
 
 #[test]

tests/solana.rs

@@ -244,7 +244,11 @@ struct AccountRef {
     length: usize,
 }
 
-fn serialize_parameters(input: &[u8], vm: &VirtualMachine) -> (Vec<u8>, Vec<AccountRef>) {
+fn serialize_parameters(
+    input: &[u8],
+    metas: &[AccountMeta],
+    vm: &VirtualMachine,
+) -> (Vec<u8>, Vec<AccountRef>) {
     let mut refs = Vec::new();
     let mut v: Vec<u8> = Vec::new();
 
@@ -252,21 +256,21 @@ fn serialize_parameters(input: &[u8], vm: &VirtualMachine) -> (Vec<u8>, Vec<Acco
     fn serialize_account(
         v: &mut Vec<u8>,
         refs: &mut Vec<AccountRef>,
-        key: &Account,
+        meta: &AccountMeta,
         acc: &AccountState,
     ) {
         // dup_info
         v.write_u8(0xff).unwrap();
         // signer
-        v.write_u8(0).unwrap();
+        v.write_u8(meta.is_signer.into()).unwrap();
         // is_writable
-        v.write_u8(1).unwrap();
+        v.write_u8(meta.is_writable.into()).unwrap();
         // executable
         v.write_u8(1).unwrap();
         // padding
         v.write_all(&[0u8; 4]).unwrap();
         // key
-        v.write_all(key).unwrap();
+        v.write_all(&meta.pubkey.0).unwrap();
         // owner
         let owner_offset = v.len();
 
@@ -278,7 +282,7 @@ fn serialize_parameters(input: &[u8], vm: &VirtualMachine) -> (Vec<u8>, Vec<Acco
         v.write_u64::<LittleEndian>(acc.data.len() as u64).unwrap();
 
         refs.push(AccountRef {
-            account: *key,
+            account: meta.pubkey.0,
             owner_offset,
             data_offset: v.len(),
             length: acc.data.len(),
@@ -298,24 +302,15 @@ fn serialize_parameters(input: &[u8], vm: &VirtualMachine) -> (Vec<u8>, Vec<Acco
     }
 
     // ka_num
-    v.write_u64::<LittleEndian>(vm.account_data.len() as u64)
-        .unwrap();
-
-    // first do the account data
-    let data_account = &vm.stack[0].data;
-
-    serialize_account(
-        &mut v,
-        &mut refs,
-        data_account,
-        &vm.account_data[data_account],
-    );
-
-    // then the rest of the accounts
-    for (acc, data) in &vm.account_data {
-        if acc != data_account {
-            serialize_account(&mut v, &mut refs, acc, data);
-        }
+    v.write_u64::<LittleEndian>(metas.len() as u64).unwrap();
+
+    for account in metas {
+        serialize_account(
+            &mut v,
+            &mut refs,
+            account,
+            &vm.account_data[&account.pubkey.0],
+        );
     }
 
     // calldata
@@ -1446,7 +1441,7 @@ impl<'a> SyscallObject<UserError> for SyscallInvokeSignedC<'a> {
 
                 vm.stack.insert(0, p);
 
-                let res = vm.execute(&instruction.data);
+                let res = vm.execute(&instruction.accounts, &instruction.data);
                 assert_eq!(res, Ok(0));
 
                 let refs = self.context.refs.try_borrow_mut().unwrap();
@@ -1462,10 +1457,14 @@ impl<'a> SyscallObject<UserError> for SyscallInvokeSignedC<'a> {
 }
 
 impl VirtualMachine {
-    fn execute(&mut self, calldata: &[u8]) -> Result<u64, EbpfError<UserError>> {
+    fn execute(
+        &mut self,
+        metas: &[AccountMeta],
+        calldata: &[u8],
+    ) -> Result<u64, EbpfError<UserError>> {
         println!("running bpf with calldata:{}", hex::encode(calldata));
 
-        let (mut parameter_bytes, mut refs) = serialize_parameters(calldata, self);
+        let (mut parameter_bytes, mut refs) = serialize_parameters(calldata, metas, self);
         let mut heap = vec![0_u8; DEFAULT_HEAP_SIZE];
 
         let program = &self.stack[0];
@@ -1599,37 +1598,37 @@ impl VirtualMachine {
         let program = &self.stack[0];
         println!("constructor for {}", hex::encode(program.data));
 
-        let mut calldata = VirtualMachine::input(&program.data, &self.origin, name);
+        let mut calldata = VirtualMachine::input(&program.data, name);
         if program.abi.as_ref().unwrap().constructor.is_some() {
             let mut encoded_data = encode_arguments(args);
             calldata.append(&mut encoded_data);
         };
 
-        let res = self.execute(&calldata);
+        let default_metas = self.default_metas();
+
+        let res = self.execute(&default_metas, &calldata);
 
         println!("res:{:?}", res);
         assert_eq!(res, Ok(expected));
     }
 
-    fn function(
+    fn function(&mut self, name: &str, args: &[BorshToken]) -> Vec<BorshToken> {
+        let default_metas = self.default_metas();
+
+        self.function_metas(&default_metas, name, args)
+    }
+
+    fn function_metas(
         &mut self,
+        metas: &[AccountMeta],
         name: &str,
         args: &[BorshToken],
-        sender: Option<&Account>,
     ) -> Vec<BorshToken> {
         let program = &self.stack[0];
 
         println!("function for {}", hex::encode(program.data));
 
-        let mut calldata = VirtualMachine::input(
-            &program.data,
-            if let Some(sender) = sender {
-                sender
-            } else {
-                &self.origin
-            },
-            name,
-        );
+        let mut calldata = VirtualMachine::input(&program.data, name);
 
         println!("input: {} ", hex::encode(&calldata));
 
@@ -1640,7 +1639,7 @@ impl VirtualMachine {
 
         println!("input: {}", hex::encode(&calldata));
 
-        let res = self.execute(&calldata);
+        let res = self.execute(metas, &calldata);
         match res {
             Ok(0) => (),
             Ok(error_code) => panic!("unexpected return {:#x}", error_code),
@@ -1661,21 +1660,12 @@ impl VirtualMachine {
         &mut self,
         name: &str,
         args: &[BorshToken],
-        sender: Option<&Account>,
     ) -> Result<u64, EbpfError<UserError>> {
         let program = &self.stack[0];
 
         println!("function for {}", hex::encode(program.data));
 
-        let mut calldata = VirtualMachine::input(
-            &program.data,
-            if let Some(sender) = sender {
-                sender
-            } else {
-                &self.origin
-            },
-            name,
-        );
+        let mut calldata = VirtualMachine::input(&program.data, name);
 
         println!("input: {}", hex::encode(&calldata));
 
@@ -1684,14 +1674,16 @@ impl VirtualMachine {
         let mut encoded = encode_arguments(args);
         calldata.append(&mut encoded);
 
+        let default_metas = self.default_metas();
+
         println!("input: {}", hex::encode(&calldata));
 
-        self.execute(&calldata)
+        self.execute(&default_metas, &calldata)
     }
 
-    fn input(recv: &Account, sender: &Account, name: &str) -> Vec<u8> {
+    fn input(recv: &Account, name: &str) -> Vec<u8> {
         let mut calldata: Vec<u8> = recv.to_vec();
-        calldata.extend_from_slice(sender);
+        calldata.extend_from_slice(&[0u8; 32]);
         calldata.extend_from_slice(&0u64.to_le_bytes());
 
         let mut hasher = Keccak::v256();
@@ -1707,6 +1699,27 @@ impl VirtualMachine {
         calldata
     }
 
+    fn default_metas(&self) -> Vec<AccountMeta> {
+        // Just include everything
+        let mut accounts = vec![AccountMeta {
+            pubkey: Pubkey(self.stack[0].data),
+            is_writable: true,
+            is_signer: false,
+        }];
+
+        for acc in self.account_data.keys() {
+            if *acc != accounts[0].pubkey.0 {
+                accounts.push(AccountMeta {
+                    pubkey: Pubkey(*acc),
+                    is_signer: false,
+                    is_writable: true,
+                });
+            }
+        }
+
+        accounts
+    }
+
     fn data(&self) -> &Vec<u8> {
         let program = &self.stack[0];
 

tests/solana_tests/abi.rs

@@ -47,10 +47,10 @@ fn packed() {
 
     vm.constructor("bar", &[]);
 
-    vm.function("test", &[], None);
-    vm.function("test2", &[], None);
-    vm.function("test3", &[], None);
-    vm.function("test4", &[], None);
+    vm.function("test", &[]);
+    vm.function("test2", &[]);
+    vm.function("test3", &[]);
+    vm.function("test4", &[]);
 }
 
 #[test]
@@ -67,7 +67,7 @@ fn inherited() {
 
     vm.constructor("bar", &[]);
 
-    vm.function("test", &[], None);
+    vm.function("test", &[]);
 
     let mut vm = build_solidity(
         r#"
@@ -80,5 +80,5 @@ fn inherited() {
 
     vm.constructor("bar", &[]);
 
-    vm.function("test", &[], None);
+    vm.function("test", &[]);
 }

tests/solana_tests/abi_decode.rs

@@ -78,7 +78,7 @@ fn integers_bool_enum() {
         h: false,
     };
     let encoded = input.try_to_vec().unwrap();
-    let _ = vm.function("decodeTest1", &[BorshToken::Bytes(encoded)], None);
+    let _ = vm.function("decodeTest1", &[BorshToken::Bytes(encoded)]);
 
     let input = Res2 {
         item_1: WeekDay::Sunday,
@@ -86,7 +86,7 @@ fn integers_bool_enum() {
         item_3: WeekDay::Friday,
     };
     let encoded = input.try_to_vec().unwrap();
-    let _ = vm.function("decodeTest2", &[BorshToken::Bytes(encoded)], None);
+    let _ = vm.function("decodeTest2", &[BorshToken::Bytes(encoded)]);
 }
 
 #[test]
@@ -116,7 +116,7 @@ fn decode_address() {
         this: vm.programs[0].data,
     };
     let encoded = input.try_to_vec().unwrap();
-    let _ = vm.function("testAddress", &[BorshToken::Bytes(encoded)], None);
+    let _ = vm.function("testAddress", &[BorshToken::Bytes(encoded)]);
 }
 
 #[test]
@@ -146,7 +146,7 @@ fn string_and_bytes() {
         b: b"tea".to_vec(),
     };
     let encoded = data.try_to_vec().unwrap();
-    let _ = vm.function("testStringAndBytes", &[BorshToken::Bytes(encoded)], None);
+    let _ = vm.function("testStringAndBytes", &[BorshToken::Bytes(encoded)]);
 }
 
 #[test]
@@ -197,7 +197,7 @@ fn primitive_struct() {
     vm.constructor("Testing", &[]);
     let data = NoPadStruct { a: 1238, b: 87123 };
     let encoded = data.try_to_vec().unwrap();
-    let _ = vm.function("testNoPadStruct", &[BorshToken::Bytes(encoded)], None);
+    let _ = vm.function("testNoPadStruct", &[BorshToken::Bytes(encoded)]);
 
     let mut elem = b"tea_is_good".to_vec();
     elem.append(&mut vec![0; 21]);
@@ -207,7 +207,7 @@ fn primitive_struct() {
         c: <[u8; 32]>::try_from(&elem[0..32]).unwrap(),
     };
     let encoded = data.try_to_vec().unwrap();
-    let _ = vm.function("testPaddedStruct", &[BorshToken::Bytes(encoded)], None);
+    let _ = vm.function("testPaddedStruct", &[BorshToken::Bytes(encoded)]);
 }
 
 #[test]
@@ -232,7 +232,7 @@ fn returned_string() {
         rr: "cortado".to_string(),
     };
     let encoded = data.try_to_vec().unwrap();
-    let returns = vm.function("returnedString", &[BorshToken::Bytes(encoded)], None);
+    let returns = vm.function("returnedString", &[BorshToken::Bytes(encoded)]);
     let string = returns[0].clone().into_string().unwrap();
     assert_eq!(string, "cortado");
 }
@@ -264,7 +264,7 @@ fn test_string_array() {
         ],
     };
     let encoded = data.try_to_vec().unwrap();
-    let returns = vm.function("testStringVector", &[BorshToken::Bytes(encoded)], None);
+    let returns = vm.function("testStringVector", &[BorshToken::Bytes(encoded)]);
     let vec = returns[0].clone().into_array().unwrap();
     assert_eq!(vec.len(), 3);
     assert_eq!(vec[0].clone().into_string().unwrap(), "coffee");
@@ -348,7 +348,7 @@ fn struct_within_struct() {
         pad,
     };
     let encoded = data.try_to_vec().unwrap();
-    let _ = vm.function("testStruct", &[BorshToken::Bytes(encoded)], None);
+    let _ = vm.function("testStruct", &[BorshToken::Bytes(encoded)]);
 }
 
 #[test]
@@ -456,7 +456,7 @@ fn struct_in_array() {
         },
     };
     let encoded = input.try_to_vec().unwrap();
-    let _ = vm.function("twoStructs", &[BorshToken::Bytes(encoded)], None);
+    let _ = vm.function("twoStructs", &[BorshToken::Bytes(encoded)]);
 
     let input = Input2 {
         item_1: [1, -298, 3, -434],
@@ -468,13 +468,13 @@ fn struct_in_array() {
         ],
     };
     let encoded = input.try_to_vec().unwrap();
-    let _ = vm.function("fixedArrays", &[BorshToken::Bytes(encoded)], None);
+    let _ = vm.function("fixedArrays", &[BorshToken::Bytes(encoded)]);
 
     let input = Input3 {
         vec: vec![NoPadStruct { a: 5, b: 6 }, NoPadStruct { a: 7, b: 8 }],
     };
     let encoded = input.try_to_vec().unwrap();
-    let _ = vm.function("primitiveDynamic", &[BorshToken::Bytes(encoded)], None);
+    let _ = vm.function("primitiveDynamic", &[BorshToken::Bytes(encoded)]);
 }
 
 #[test]
@@ -561,19 +561,19 @@ fn arrays() {
         ],
     };
     let encoded = input.try_to_vec().unwrap();
-    let _ = vm.function("decodeComplex", &[BorshToken::Bytes(encoded)], None);
+    let _ = vm.function("decodeComplex", &[BorshToken::Bytes(encoded)]);
 
     let input = Input2 {
         vec: vec![-90, 5523, -89],
     };
     let encoded = input.try_to_vec().unwrap();
-    let _ = vm.function("dynamicArray", &[BorshToken::Bytes(encoded)], None);
+    let _ = vm.function("dynamicArray", &[BorshToken::Bytes(encoded)]);
 
     let input = Input3 {
         multi_dim: [[1, 2], [4, 5], [6, 7]],
     };
     let encoded = input.try_to_vec().unwrap();
-    let _ = vm.function("decodeMultiDim", &[BorshToken::Bytes(encoded)], None);
+    let _ = vm.function("decodeMultiDim", &[BorshToken::Bytes(encoded)]);
 }
 
 #[test]
@@ -727,7 +727,7 @@ fn multi_dimensional_arrays() {
         item_2: -90,
     };
     let encoded = input.try_to_vec().unwrap();
-    let _ = vm.function("multiDimStruct", &[BorshToken::Bytes(encoded)], None);
+    let _ = vm.function("multiDimStruct", &[BorshToken::Bytes(encoded)]);
 
     let input = Input2 {
         vec: vec![
@@ -736,13 +736,13 @@ fn multi_dimensional_arrays() {
         ],
     };
     let encoded = input.try_to_vec().unwrap();
-    let _ = vm.function("multiDimInt", &[BorshToken::Bytes(encoded)], None);
+    let _ = vm.function("multiDimInt", &[BorshToken::Bytes(encoded)]);
 
     let input = Input3 {
         vec: vec![9, 3, 4, 90, 834],
     };
     let encoded = input.try_to_vec().unwrap();
-    let _ = vm.function("uniqueDim", &[BorshToken::Bytes(encoded)], None);
+    let _ = vm.function("uniqueDim", &[BorshToken::Bytes(encoded)]);
 }
 
 #[test]
@@ -783,7 +783,7 @@ fn empty_arrays() {
         vec_2: vec![],
     };
     let encoded = input.try_to_vec().unwrap();
-    let _ = vm.function("testEmpty", &[BorshToken::Bytes(encoded)], None);
+    let _ = vm.function("testEmpty", &[BorshToken::Bytes(encoded)]);
 }
 
 #[test]
@@ -814,7 +814,7 @@ fn external_function() {
         ],
     };
     let encoded = input.try_to_vec().unwrap();
-    let returns = vm.function("testExternalFunction", &[BorshToken::Bytes(encoded)], None);
+    let returns = vm.function("testExternalFunction", &[BorshToken::Bytes(encoded)]);
 
     let selector = returns[0].clone().into_fixed_bytes().unwrap();
     assert_eq!(selector, input.selector);
@@ -854,7 +854,7 @@ fn bytes_arrays() {
         item_2: vec![b"12345".to_owned(), b"67890".to_owned()],
     };
     let encoded = input.try_to_vec().unwrap();
-    let _ = vm.function("testByteArrays", &[BorshToken::Bytes(encoded)], None);
+    let _ = vm.function("testByteArrays", &[BorshToken::Bytes(encoded)]);
 }
 
 #[test]
@@ -886,7 +886,7 @@ fn different_types() {
     vm.constructor("Testing", &[]);
     let input = Input1 { a: -789, b: 14234 };
     let encoded = input.try_to_vec().unwrap();
-    let _ = vm.function("testByteArrays", &[BorshToken::Bytes(encoded)], None);
+    let _ = vm.function("testByteArrays", &[BorshToken::Bytes(encoded)]);
 }
 
 #[test]
@@ -913,7 +913,7 @@ fn more_elements() {
 
     let input = Input { vec: [1, 4, 5, 6] };
     let encoded = input.try_to_vec().unwrap();
-    let _ = vm.function("wrongNumber", &[BorshToken::Bytes(encoded)], None);
+    let _ = vm.function("wrongNumber", &[BorshToken::Bytes(encoded)]);
 }
 
 #[test]
@@ -943,7 +943,7 @@ fn extra_element() {
     };
 
     let encoded = input.try_to_vec().unwrap();
-    let _ = vm.function("extraElement", &[BorshToken::Bytes(encoded)], None);
+    let _ = vm.function("extraElement", &[BorshToken::Bytes(encoded)]);
 }
 
 #[test]
@@ -970,7 +970,7 @@ fn invalid_type() {
 
     let input = Input { item: 5 };
     let encoded = input.try_to_vec().unwrap();
-    let _ = vm.function("invalidType", &[BorshToken::Bytes(encoded)], None);
+    let _ = vm.function("invalidType", &[BorshToken::Bytes(encoded)]);
 }
 
 #[test]
@@ -1001,7 +1001,7 @@ fn longer_buffer() {
         item_2: 5,
     };
     let encoded = input.try_to_vec().unwrap();
-    let _ = vm.function("testLongerBuffer", &[BorshToken::Bytes(encoded)], None);
+    let _ = vm.function("testLongerBuffer", &[BorshToken::Bytes(encoded)]);
 }
 
 #[test]
@@ -1033,7 +1033,7 @@ fn longer_buffer_array() {
         item_2: [1, 2, 3, 4],
     };
     let encoded = input.try_to_vec().unwrap();
-    let _ = vm.function("testLongerBuffer", &[BorshToken::Bytes(encoded)], None);
+    let _ = vm.function("testLongerBuffer", &[BorshToken::Bytes(encoded)]);
 }
 
 #[test]
@@ -1065,7 +1065,7 @@ fn dynamic_array_of_array() {
         vec: vec![[0, 1], [2, -3]],
     };
     let encoded = input.try_to_vec().unwrap();
-    let _ = vm.function("testArrayAssign", &[BorshToken::Bytes(encoded)], None);
+    let _ = vm.function("testArrayAssign", &[BorshToken::Bytes(encoded)]);
 }
 
 #[test]
@@ -1118,7 +1118,7 @@ fn test_struct_validation() {
         },
     };
     let encoded = input.try_to_vec().unwrap();
-    let _ = vm.function("test", &[BorshToken::Bytes(encoded)], None);
+    let _ = vm.function("test", &[BorshToken::Bytes(encoded)]);
 }
 
 #[test]
@@ -1170,7 +1170,7 @@ fn test_struct_validation_invalid() {
         },
     };
     let encoded = input.try_to_vec().unwrap();
-    let _ = vm.function("test", &[BorshToken::Bytes(encoded)], None);
+    let _ = vm.function("test", &[BorshToken::Bytes(encoded)]);
 }
 
 #[test]
@@ -1204,5 +1204,5 @@ fn string_fixed_array() {
         ],
     };
     let encoded = input.try_to_vec().unwrap();
-    let _ = vm.function("testing", &[BorshToken::Bytes(encoded)], None);
+    let _ = vm.function("testing", &[BorshToken::Bytes(encoded)]);
 }

tests/solana_tests/abi_encode.rs

@@ -68,7 +68,7 @@ contract Testing {
     );
 
     vm.constructor("Testing", &[]);
-    let returns = vm.function("getThis", &[], None);
+    let returns = vm.function("getThis", &[]);
     let encoded = returns[0].clone().into_bytes().unwrap();
     let decoded = Res1::try_from_slice(&encoded).unwrap();
 
@@ -80,7 +80,7 @@ contract Testing {
     assert_eq!(decoded.day, WeekDay::Wednesday);
     assert!(!decoded.h);
 
-    let returns = vm.function("encodeEnum", &[], None);
+    let returns = vm.function("encodeEnum", &[]);
     let encoded = returns[0].clone().into_bytes().unwrap();
     let decoded = Res2::try_from_slice(&encoded).unwrap();
 
@@ -109,7 +109,7 @@ contract Testing {
         "#,
     );
     vm.constructor("Testing", &[]);
-    let returns = vm.function("getThis", &[], None);
+    let returns = vm.function("getThis", &[]);
     let encoded = returns[0].clone().into_bytes().unwrap();
     let decoded = Response::try_from_slice(&encoded).unwrap();
     assert_eq!(decoded.address, vm.programs[0].data);
@@ -139,7 +139,7 @@ contract Testing {
     );
 
     vm.constructor("Testing", &[]);
-    let returns = vm.function("getThis", &[], None);
+    let returns = vm.function("getThis", &[]);
     let encoded = returns[0].clone().into_bytes().unwrap();
     let decoded = MyStruct::try_from_slice(&encoded).unwrap();
     assert_eq!(decoded.a, "coffe");
@@ -191,13 +191,13 @@ fn primitive_structs() {
         "#,
     );
     vm.constructor("Testing", &[]);
-    let returns = vm.function("getThis", &[], None);
+    let returns = vm.function("getThis", &[]);
     let encoded = returns[0].clone().into_bytes().unwrap();
     let decoded = NoPadStruct::try_from_slice(&encoded).unwrap();
     assert_eq!(decoded.a, 1238);
     assert_eq!(decoded.b, 87123);
 
-    let returns = vm.function("getThat", &[], None);
+    let returns = vm.function("getThat", &[]);
     let encoded = returns[0].clone().into_bytes().unwrap();
     let decoded = PaddedStruct::try_from_slice(&encoded).unwrap();
     assert_eq!(decoded.a, 12998);
@@ -226,11 +226,7 @@ contract Testing {
     );
 
     vm.constructor("Testing", &[]);
-    let returns = vm.function(
-        "testStruct",
-        &[BorshToken::String("nihao".to_string())],
-        None,
-    );
+    let returns = vm.function("testStruct", &[BorshToken::String("nihao".to_string())]);
     let encoded = returns[0].clone().into_bytes().unwrap();
     let decoded = Response::try_from_slice(&encoded).unwrap();
     assert_eq!(decoded.rr, "nihao");
@@ -262,13 +258,13 @@ fn test_string_array() {
     );
 
     vm.constructor("Testing", &[]);
-    let returns = vm.function("encode", &[], None);
+    let returns = vm.function("encode", &[]);
     let encoded = returns[0].clone().into_bytes().unwrap();
     let decoded = Response::try_from_slice(&encoded).unwrap();
     assert_eq!(decoded.a.len(), 0);
 
-    let _ = vm.function("insertStrings", &[], None);
-    let returns = vm.function("encode", &[], None);
+    let _ = vm.function("insertStrings", &[]);
+    let returns = vm.function("encode", &[]);
     let encoded = returns[0].clone().into_bytes().unwrap();
     let decoded = Response::try_from_slice(&encoded).unwrap();
     assert_eq!(decoded.a.len(), 2);
@@ -339,7 +335,7 @@ contract Testing {
     );
 
     vm.constructor("Testing", &[]);
-    let returns = vm.function("testStruct", &[], None);
+    let returns = vm.function("testStruct", &[]);
     let encoded = returns[0].clone().into_bytes().unwrap();
     let decoded = NonConstantStruct::try_from_slice(&encoded).unwrap();
 
@@ -442,8 +438,8 @@ fn struct_in_array() {
     );
 
     vm.constructor("Testing", &[]);
-    let _ = vm.function("addData", &[], None);
-    let returns = vm.function("encodeStruct", &[], None);
+    let _ = vm.function("addData", &[]);
+    let returns = vm.function("encodeStruct", &[]);
     let encoded = returns[0].clone().into_bytes().unwrap();
     let decoded = Res1::try_from_slice(&encoded).unwrap();
 
@@ -454,7 +450,7 @@ fn struct_in_array() {
     let b: [u8; 21] = b"there_is_padding_here".to_owned();
     assert_eq!(&decoded.item_2.c[0..21], b);
 
-    let returns = vm.function("primitiveStruct", &[], None);
+    let returns = vm.function("primitiveStruct", &[]);
     let encoded = returns[0].clone().into_bytes().unwrap();
     let decoded = Res2::try_from_slice(&encoded).unwrap();
 
@@ -466,7 +462,7 @@ fn struct_in_array() {
     assert_eq!(decoded.item_3[0], NoPadStruct { a: 1, b: 2 });
     assert_eq!(decoded.item_3[1], NoPadStruct { a: 3, b: 4 });
 
-    let returns = vm.function("primitiveDynamicArray", &[], None);
+    let returns = vm.function("primitiveDynamicArray", &[]);
     let encoded = returns[0].clone().into_bytes().unwrap();
     let decoded = Res3::try_from_slice(&encoded).unwrap();
 
@@ -542,8 +538,8 @@ fn arrays() {
     );
 
     vm.constructor("Testing", &[]);
-    let _ = vm.function("addData", &[], None);
-    let returns = vm.function("encodeArray", &[], None);
+    let _ = vm.function("addData", &[]);
+    let returns = vm.function("encodeArray", &[]);
     let encoded = returns[0].clone().into_bytes().unwrap();
     let decoded = Res1::try_from_slice(&encoded).unwrap();
 
@@ -552,7 +548,7 @@ fn arrays() {
     assert_eq!(decoded.vec_1[1], 5523);
     assert_eq!(decoded.vec_1[2], -89);
 
-    let returns = vm.function("encodeComplex", &[], None);
+    let returns = vm.function("encodeComplex", &[]);
     let encoded = returns[0].clone().into_bytes().unwrap();
     let decoded = Res2::try_from_slice(&encoded).unwrap();
 
@@ -568,7 +564,7 @@ fn arrays() {
         vec!["cortado".to_string(), "cappuccino".to_string()]
     );
 
-    let returns = vm.function("multiDimArrays", &[], None);
+    let returns = vm.function("multiDimArrays", &[]);
     let encoded = returns[0].clone().into_bytes().unwrap();
     let decoded = Res3::try_from_slice(&encoded).unwrap();
 
@@ -655,7 +651,7 @@ contract Testing {
     );
 
     vm.constructor("Testing", &[]);
-    let returns = vm.function("getThis", &[], None);
+    let returns = vm.function("getThis", &[]);
     let encoded = returns[0].clone().into_bytes().unwrap();
     let decoded = Res1::try_from_slice(&encoded).unwrap();
 
@@ -713,7 +709,7 @@ contract Testing {
     );
     assert_eq!(decoded.item_2, 5);
 
-    let returns = vm.function("multiDim", &[], None);
+    let returns = vm.function("multiDim", &[]);
     let encoded = returns[0].clone().into_bytes().unwrap();
     let decoded = Res2::try_from_slice(&encoded).unwrap();
 
@@ -721,7 +717,7 @@ contract Testing {
     assert_eq!(decoded.item[0][0], [1, 2, 3, 4]);
     assert_eq!(decoded.item[0][1], [5, 6, 7, 8]);
 
-    let returns = vm.function("uniqueDim", &[], None);
+    let returns = vm.function("uniqueDim", &[]);
     let encoded = returns[0].clone().into_bytes().unwrap();
     let decoded = Res3::try_from_slice(&encoded).unwrap();
 
@@ -776,7 +772,7 @@ fn null_pointer() {
     );
 
     vm.constructor("Testing", &[]);
-    let returns = vm.function("test1", &[], None);
+    let returns = vm.function("test1", &[]);
     let encoded = returns[0].clone().into_bytes().unwrap();
     let decoded = Res1::try_from_slice(&encoded).unwrap();
 
@@ -786,7 +782,7 @@ fn null_pointer() {
         assert!(decoded.item[i].f2.is_empty())
     }
 
-    let returns = vm.function("test2", &[], None);
+    let returns = vm.function("test2", &[]);
     let encoded = returns[0].clone().into_bytes().unwrap();
     let decoded = Res2::try_from_slice(&encoded).unwrap();
 
@@ -824,7 +820,7 @@ fn external_function() {
 
     vm.constructor("Testing", &[]);
 
-    let returns = vm.function("doThat", &[], None);
+    let returns = vm.function("doThat", &[]);
     let encoded = returns[2].clone().into_bytes().unwrap();
     let decoded = Res::try_from_slice(&encoded).unwrap();
 
@@ -858,7 +854,7 @@ fn bytes_arrays() {
         "#,
     );
     vm.constructor("Testing", &[]);
-    let returns = vm.function("testBytesArray", &[], None);
+    let returns = vm.function("testBytesArray", &[]);
     let encoded = returns[0].clone().into_bytes().unwrap();
     let decoded = Res::try_from_slice(&encoded).unwrap();
 
@@ -897,7 +893,7 @@ fn uint8_arrays() {
     );
 
     vm.constructor("Testing", &[]);
-    let returns = vm.function("testBytesArray", &[], None);
+    let returns = vm.function("testBytesArray", &[]);
     let encoded = returns[0].clone().into_bytes().unwrap();
     let decoded = Res::try_from_slice(&encoded).unwrap();
 
@@ -912,7 +908,6 @@ fn uint8_arrays() {
 fn multiple_external_calls() {
     let mut vm = build_solidity(
         r#"
-
 contract caller {
     function doThis(int64 a) public pure returns (int64) {
         return a + 2;
@@ -925,13 +920,12 @@ contract caller {
     function do_call() pure public returns (int64, int32) {
         return (this.doThis(5), this.doThat(3));
     }
-}
-        "#,
+}"#,
     );
 
     vm.constructor("caller", &[]);
 
-    let returns = vm.function("do_call", &[], None);
+    let returns = vm.function("do_call", &[]);
     assert_eq!(returns.len(), 2);
     assert_eq!(
         returns[0],

tests/solana_tests/accessor.rs

@@ -15,7 +15,7 @@ fn types() {
 
     vm.constructor("foo", &[]);
 
-    let returns = vm.function("f1", &[], None);
+    let returns = vm.function("f1", &[]);
 
     assert_eq!(
         returns,
@@ -40,7 +40,6 @@ fn types() {
             width: 256,
             value: BigInt::from(2u8),
         }],
-        None,
     );
 
     assert_eq!(
@@ -79,7 +78,6 @@ fn types() {
                 value: BigInt::from(2u8),
             },
         ],
-        None,
     );
 
     assert_eq!(
@@ -110,7 +108,6 @@ fn types() {
             width: 64,
             value: BigInt::from(4000u16),
         }],
-        None,
     );
 
     assert_eq!(
@@ -138,7 +135,7 @@ fn interfaces() {
 
     vm.constructor("foo", &[]);
 
-    let returns = vm.function("f1", &[], None);
+    let returns = vm.function("f1", &[]);
 
     assert_eq!(returns, vec![BorshToken::FixedBytes(b"ab".to_vec())]);
 }
@@ -154,7 +151,7 @@ fn constant() {
 
     vm.constructor("x", &[]);
 
-    let returns = vm.function("z", &[], None);
+    let returns = vm.function("z", &[]);
 
     assert_eq!(
         returns,
@@ -173,7 +170,7 @@ fn constant() {
 
     vm.constructor("x", &[]);
 
-    let returns = vm.function("z", &[], None);
+    let returns = vm.function("z", &[]);
 
     assert_eq!(
         returns,
@@ -192,7 +189,7 @@ fn constant() {
 
     vm.constructor("x", &[]);
 
-    let returns = vm.function("z", &[], None);
+    let returns = vm.function("z", &[]);
 
     assert_eq!(
         returns,

tests/solana_tests/account_info.rs

@@ -9,7 +9,7 @@ fn lamports() {
         r#"
         import 'solana';
         contract c {
-            function test() public payable returns (uint64) {
+            function test(address needle) public payable returns (uint64) {
                 for (uint32 i = 0; i < tx.accounts.length; i++) {
                     AccountInfo ai = tx.accounts[i];
 
@@ -17,7 +17,7 @@ fn lamports() {
                     assert(!ai.is_signer);
                     assert(ai.executable);
 
-                    if (ai.key == msg.sender) {
+                    if (ai.key == needle) {
                         return ai.lamports;
                     }
                 }
@@ -31,7 +31,7 @@ fn lamports() {
 
     vm.account_data.get_mut(&vm.origin).unwrap().lamports = 17672630920854456917u64;
 
-    let returns = vm.function("test", &[], None);
+    let returns = vm.function("test", &[BorshToken::Address(vm.origin)]);
 
     assert_eq!(
         returns[0],
@@ -64,7 +64,7 @@ fn owner() {
 
     vm.constructor("c", &[]);
 
-    let returns = vm.function("test", &[], None);
+    let returns = vm.function("test", &[]);
 
     let owner = vm.stack[0].program.to_vec();
 
@@ -112,7 +112,6 @@ fn data() {
                 width: 32,
                 value: BigInt::from(i),
             }],
-            None,
         );
 
         let this = &vm.stack[0].data;
@@ -128,7 +127,7 @@ fn data() {
         );
     }
 
-    let returns = vm.function("test2", &[], None);
+    let returns = vm.function("test2", &[]);
 
     let this = &vm.stack[0].data;
 

tests/solana_tests/arrays.rs

@@ -22,7 +22,7 @@ fn fixed_array() {
 
     vm.constructor("foo", &[]);
 
-    let returns = vm.function("get", &[], None);
+    let returns = vm.function("get", &[]);
 
     assert_eq!(
         returns,
@@ -68,7 +68,7 @@ fn fixed_array() {
 
     vm.constructor("foo", &[]);
 
-    let returns = vm.function("get", &[], None);
+    let returns = vm.function("get", &[]);
 
     assert_eq!(
         returns,
@@ -137,7 +137,7 @@ fn fixed_array() {
 
     vm.constructor("foo", &[]);
 
-    let returns = vm.function("get", &[], None);
+    let returns = vm.function("get", &[]);
 
     assert_eq!(
         returns,
@@ -189,7 +189,6 @@ fn fixed_array() {
             ]),
             BorshToken::Bool(true),
         ])],
-        None,
     );
 
     assert_eq!(
@@ -261,7 +260,6 @@ fn dynamic_array_fixed_elements() {
                 value: BigInt::from(102u8),
             },
         ],
-        None,
     );
 
     assert_eq!(
@@ -273,7 +271,7 @@ fn dynamic_array_fixed_elements() {
     );
 
     // test that the abi encoder can handle fixed arrays
-    let returns = vm.function("set", &[], None);
+    let returns = vm.function("set", &[]);
 
     assert_eq!(
         returns,
@@ -356,7 +354,6 @@ fn fixed_array_dynamic_elements() {
                 value: BigInt::from(102u8),
             },
         ],
-        None,
     );
 
     assert_eq!(
@@ -367,7 +364,7 @@ fn fixed_array_dynamic_elements() {
         }]
     );
 
-    let returns = vm.function("set", &[], None);
+    let returns = vm.function("set", &[]);
 
     assert_eq!(
         returns,
@@ -442,7 +439,6 @@ fn dynamic_array_dynamic_elements() {
                 value: BigInt::from(102u8),
             },
         ],
-        None,
     );
 
     assert_eq!(
@@ -453,7 +449,7 @@ fn dynamic_array_dynamic_elements() {
         }]
     );
 
-    let returns = vm.function("set", &[], None);
+    let returns = vm.function("set", &[]);
 
     assert_eq!(
         returns,
@@ -516,7 +512,6 @@ fn fixed_array_fixed_elements_storage() {
                 value: BigInt::from(12123123u64),
             },
         ],
-        None,
     );
 
     vm.function(
@@ -531,7 +526,6 @@ fn fixed_array_fixed_elements_storage() {
                 value: BigInt::from(123456789u64),
             },
         ],
-        None,
     );
 
     let returns = vm.function(
@@ -540,7 +534,6 @@ fn fixed_array_fixed_elements_storage() {
             width: 256,
             value: BigInt::from(2u8),
         }],
-        None,
     );
 
     assert_eq!(
@@ -551,7 +544,7 @@ fn fixed_array_fixed_elements_storage() {
         },]
     );
 
-    let returns = vm.function("get", &[], None);
+    let returns = vm.function("get", &[]);
 
     assert_eq!(
         returns,
@@ -595,10 +588,9 @@ fn fixed_array_fixed_elements_storage() {
                 value: BigInt::from(4u8),
             },
         ])],
-        None,
     );
 
-    let returns = vm.function("get", &[], None);
+    let returns = vm.function("get", &[]);
 
     assert_eq!(
         returns,
@@ -622,9 +614,9 @@ fn fixed_array_fixed_elements_storage() {
         ])],
     );
 
-    vm.function("del", &[], None);
+    vm.function("del", &[]);
 
-    let returns = vm.function("get", &[], None);
+    let returns = vm.function("get", &[]);
 
     assert_eq!(
         returns,
@@ -689,7 +681,6 @@ fn fixed_array_dynamic_elements_storage() {
             },
             BorshToken::String(String::from("abcd")),
         ],
-        None,
     );
 
     vm.function(
@@ -703,7 +694,6 @@ fn fixed_array_dynamic_elements_storage() {
                 "you can lead a horse to water but you can’t make him drink",
             )),
         ],
-        None,
     );
 
     let returns = vm.function(
@@ -712,12 +702,11 @@ fn fixed_array_dynamic_elements_storage() {
             width: 256,
             value: BigInt::from(2u8),
         }],
-        None,
     );
 
     assert_eq!(returns, vec![BorshToken::String(String::from("abcd"))]);
 
-    let returns = vm.function("get", &[], None);
+    let returns = vm.function("get", &[]);
 
     assert_eq!(
         returns,
@@ -739,10 +728,9 @@ fn fixed_array_dynamic_elements_storage() {
             BorshToken::String(String::from("c")),
             BorshToken::String(String::from("d")),
         ])],
-        None,
     );
 
-    let returns = vm.function("get", &[], None);
+    let returns = vm.function("get", &[]);
 
     assert_eq!(
         returns,
@@ -754,9 +742,9 @@ fn fixed_array_dynamic_elements_storage() {
         ])],
     );
 
-    vm.function("del", &[], None);
+    vm.function("del", &[]);
 
-    let returns = vm.function("get", &[], None);
+    let returns = vm.function("get", &[]);
 
     assert_eq!(
         returns,
@@ -812,7 +800,7 @@ fn storage_simple_dynamic_array() {
 
     vm.constructor("foo", &[]);
 
-    let returns = vm.function("len", &[], None);
+    let returns = vm.function("len", &[]);
 
     assert_eq!(
         returns,
@@ -828,10 +816,9 @@ fn storage_simple_dynamic_array() {
             width: 64,
             value: BigInt::from(102u8),
         }],
-        None,
     );
 
-    vm.function("push_zero", &[], None);
+    vm.function("push_zero", &[]);
 
     vm.function(
         "push",
@@ -839,7 +826,6 @@ fn storage_simple_dynamic_array() {
             width: 64,
             value: BigInt::from(12345678901u64),
         }],
-        None,
     );
 
     let returns = vm.function(
@@ -848,7 +834,6 @@ fn storage_simple_dynamic_array() {
             width: 32,
             value: BigInt::zero(),
         }],
-        None,
     );
 
     assert_eq!(
@@ -865,7 +850,6 @@ fn storage_simple_dynamic_array() {
             width: 32,
             value: BigInt::one(),
         }],
-        None,
     );
 
     assert_eq!(
@@ -882,7 +866,6 @@ fn storage_simple_dynamic_array() {
             width: 32,
             value: BigInt::from(2u8),
         }],
-        None,
     );
 
     assert_eq!(
@@ -893,7 +876,7 @@ fn storage_simple_dynamic_array() {
         },]
     );
 
-    let returns = vm.function("copy", &[], None);
+    let returns = vm.function("copy", &[]);
 
     assert_eq!(
         returns,
@@ -913,7 +896,7 @@ fn storage_simple_dynamic_array() {
         ])],
     );
 
-    let returns = vm.function("pop", &[], None);
+    let returns = vm.function("pop", &[]);
 
     assert_eq!(
         returns,
@@ -923,7 +906,7 @@ fn storage_simple_dynamic_array() {
         },]
     );
 
-    let returns = vm.function("len", &[], None);
+    let returns = vm.function("len", &[]);
 
     assert_eq!(
         returns,
@@ -965,10 +948,9 @@ fn storage_simple_dynamic_array() {
                 value: BigInt::from(7u8),
             },
         ])],
-        None,
     );
 
-    let returns = vm.function("copy", &[], None);
+    let returns = vm.function("copy", &[]);
 
     assert_eq!(
         returns,
@@ -1004,9 +986,9 @@ fn storage_simple_dynamic_array() {
         ])],
     );
 
-    vm.function("rm", &[], None);
+    vm.function("rm", &[]);
 
-    let returns = vm.function("len", &[], None);
+    let returns = vm.function("len", &[]);
 
     assert_eq!(
         returns,
@@ -1033,7 +1015,7 @@ fn storage_pop_running_on_empty() {
 
     vm.constructor("foo", &[]);
 
-    vm.function("pop", &[], None);
+    vm.function("pop", &[]);
 }
 
 #[test]
@@ -1090,7 +1072,7 @@ fn storage_dynamic_array_of_structs() {
 
     vm.constructor("foo", &[]);
 
-    let returns = vm.function("len", &[], None);
+    let returns = vm.function("len", &[]);
 
     assert_eq!(
         returns,
@@ -1109,10 +1091,9 @@ fn storage_dynamic_array_of_structs() {
             },
             BorshToken::Bool(true),
         ])],
-        None,
     );
 
-    vm.function("push_empty", &[], None);
+    vm.function("push_empty", &[]);
 
     vm.function(
         "push2",
@@ -1123,7 +1104,6 @@ fn storage_dynamic_array_of_structs() {
             },
             BorshToken::Bool(true),
         ])],
-        None,
     );
 
     let returns = vm.function(
@@ -1132,7 +1112,6 @@ fn storage_dynamic_array_of_structs() {
             width: 32,
             value: BigInt::zero(),
         }],
-        None,
     );
 
     assert_eq!(
@@ -1152,7 +1131,6 @@ fn storage_dynamic_array_of_structs() {
             width: 32,
             value: BigInt::one(),
         }],
-        None,
     );
 
     assert_eq!(
@@ -1172,7 +1150,6 @@ fn storage_dynamic_array_of_structs() {
             width: 32,
             value: BigInt::from(2u8),
         }],
-        None,
     );
 
     assert_eq!(
@@ -1186,7 +1163,7 @@ fn storage_dynamic_array_of_structs() {
         ]),]
     );
 
-    let returns = vm.function("copy", &[], None);
+    let returns = vm.function("copy", &[]);
 
     assert_eq!(
         returns,
@@ -1215,7 +1192,7 @@ fn storage_dynamic_array_of_structs() {
         ])]
     );
 
-    let returns = vm.function("pop", &[], None);
+    let returns = vm.function("pop", &[]);
 
     assert_eq!(
         returns,
@@ -1228,7 +1205,7 @@ fn storage_dynamic_array_of_structs() {
         ])]
     );
 
-    let returns = vm.function("len", &[], None);
+    let returns = vm.function("len", &[]);
 
     assert_eq!(
         returns,
@@ -1284,10 +1261,9 @@ fn storage_dynamic_array_of_structs() {
                 BorshToken::Bool(true),
             ]),
         ])],
-        None,
     );
 
-    let returns = vm.function("copy", &[], None);
+    let returns = vm.function("copy", &[]);
 
     assert_eq!(
         returns,
@@ -1337,9 +1313,9 @@ fn storage_dynamic_array_of_structs() {
         ]),]
     );
 
-    vm.function("rm", &[], None);
+    vm.function("rm", &[]);
 
-    let returns = vm.function("len", &[], None);
+    let returns = vm.function("len", &[]);
 
     assert_eq!(
         returns,
@@ -1366,7 +1342,7 @@ fn array_literal() {
 
     vm.constructor("foo", &[]);
 
-    let returns = vm.function("list", &[], None);
+    let returns = vm.function("list", &[]);
 
     assert_eq!(
         returns,
@@ -1441,15 +1417,15 @@ fn storage_pop_push() {
     );
 
     vm.constructor("Testing", &[]);
-    vm.function("fn1", &[], None);
-    vm.function("fn2", &[], None);
-    vm.function("fn3", &[], None);
-    vm.function("fn4", &[], None);
-    vm.function("fn5", &[], None);
-    vm.function("fn6", &[], None);
-    vm.function("fn7", &[], None);
-    vm.function("fn8", &[], None);
-    vm.function("clear", &[], None);
+    vm.function("fn1", &[]);
+    vm.function("fn2", &[]);
+    vm.function("fn3", &[]);
+    vm.function("fn4", &[]);
+    vm.function("fn5", &[]);
+    vm.function("fn6", &[]);
+    vm.function("fn7", &[]);
+    vm.function("fn8", &[]);
+    vm.function("clear", &[]);
 
     // make sure every thing has been freed
     assert_eq!(vm.validate_account_data_heap(), 0);
@@ -1493,7 +1469,6 @@ fn initialization_with_literal() {
             BorshToken::FixedBytes(addr1[..].to_vec()),
             BorshToken::FixedBytes(addr2[..].to_vec()),
         ],
-        None,
     );
     let returns = vm.function(
         "getIdx",
@@ -1501,7 +1476,6 @@ fn initialization_with_literal() {
             width: 32,
             value: BigInt::zero(),
         }],
-        None,
     );
     let returned_addr1 = returns[0].clone().into_fixed_bytes().unwrap();
     assert_eq!(addr1, returned_addr1);
@@ -1512,7 +1486,6 @@ fn initialization_with_literal() {
             width: 32,
             value: BigInt::one(),
         }],
-        None,
     );
     let returned_addr2 = returns[0].clone().into_fixed_bytes().unwrap();
     assert_eq!(addr2, returned_addr2);
@@ -1529,7 +1502,6 @@ fn initialization_with_literal() {
                 value: BigInt::from(895u16),
             },
         ],
-        None,
     );
     let array = returns[0].clone().into_array().unwrap();
     assert_eq!(
@@ -1568,7 +1540,7 @@ fn dynamic_array_push() {
     );
 
     runtime.constructor("foo", &[]);
-    runtime.function("test", &[], None);
+    runtime.function("test", &[]);
 
     let mut runtime = build_solidity(
         r#"
@@ -1589,7 +1561,7 @@ fn dynamic_array_push() {
     );
 
     runtime.constructor("foo", &[]);
-    runtime.function("test", &[], None);
+    runtime.function("test", &[]);
 
     let mut runtime = build_solidity(
         r#"
@@ -1615,7 +1587,7 @@ fn dynamic_array_push() {
     );
 
     runtime.constructor("foo", &[]);
-    runtime.function("test", &[], None);
+    runtime.function("test", &[]);
 
     let mut runtime = build_solidity(
         r#"
@@ -1637,7 +1609,7 @@ fn dynamic_array_push() {
     );
 
     runtime.constructor("foo", &[]);
-    runtime.function("test", &[], None);
+    runtime.function("test", &[]);
 
     // push() returns a reference to the thing
     let mut runtime = build_solidity(
@@ -1663,7 +1635,7 @@ fn dynamic_array_push() {
     );
 
     runtime.constructor("foo", &[]);
-    runtime.function("test", &[], None);
+    runtime.function("test", &[]);
 }
 
 #[test]
@@ -1687,7 +1659,7 @@ fn dynamic_array_pop() {
     );
 
     runtime.constructor("foo", &[]);
-    runtime.function("test", &[], None);
+    runtime.function("test", &[]);
 
     let mut runtime = build_solidity(
         r#"
@@ -1708,7 +1680,7 @@ fn dynamic_array_pop() {
     );
 
     runtime.constructor("foo", &[]);
-    runtime.function("test", &[], None);
+    runtime.function("test", &[]);
 
     let mut runtime = build_solidity(
         r#"
@@ -1736,7 +1708,7 @@ fn dynamic_array_pop() {
     );
 
     runtime.constructor("foo", &[]);
-    runtime.function("test", &[], None);
+    runtime.function("test", &[]);
 
     let mut runtime = build_solidity(
         r#"
@@ -1758,7 +1730,7 @@ fn dynamic_array_pop() {
     );
 
     runtime.constructor("foo", &[]);
-    runtime.function("test", &[], None);
+    runtime.function("test", &[]);
 }
 
 #[test]
@@ -1777,7 +1749,7 @@ fn dynamic_array_pop_empty_array() {
     );
 
     runtime.constructor("foo", &[]);
-    runtime.function("test", &[], None);
+    runtime.function("test", &[]);
 }
 
 #[test]
@@ -1799,7 +1771,7 @@ fn dynamic_array_pop_bounds() {
     );
 
     runtime.constructor("foo", &[]);
-    runtime.function("test", &[], None);
+    runtime.function("test", &[]);
 }
 
 #[test]
@@ -1839,7 +1811,7 @@ fn dynamic_array_push_pop_loop() {
     );
 
     runtime.constructor("foo", &[]);
-    runtime.function("test", &[], None);
+    runtime.function("test", &[]);
 
     let mut runtime = build_solidity(
         r#"
@@ -1878,5 +1850,5 @@ fn dynamic_array_push_pop_loop() {
     );
 
     runtime.constructor("foo", &[]);
-    runtime.function("test", &[], None);
+    runtime.function("test", &[]);
 }

tests/solana_tests/balance.rs

@@ -9,8 +9,8 @@ fn get_balance() {
     let mut vm = build_solidity(
         r#"
         contract c {
-            function test() public view returns (uint64) {
-                return msg.sender.balance;
+            function test(address addr) public view returns (uint64) {
+                return addr.balance;
             }
         }"#,
     );
@@ -28,7 +28,7 @@ fn get_balance() {
         },
     );
 
-    let returns = vm.function("test", &[], Some(&new));
+    let returns = vm.function("test", &[BorshToken::Address(new)]);
 
     assert_eq!(
         returns,
@@ -72,7 +72,6 @@ fn send_fails() {
                 value: BigInt::from(102u8),
             },
         ],
-        None,
     );
 
     assert_eq!(returns, vec![BorshToken::Bool(false)]);
@@ -115,7 +114,6 @@ fn send_succeeds() {
                 value: BigInt::from(102u8),
             },
         ],
-        None,
     );
 
     assert_eq!(returns, vec![BorshToken::Bool(true)]);
@@ -163,7 +161,6 @@ fn send_overflows() {
                 value: BigInt::from(102u8),
             },
         ],
-        None,
     );
 
     assert_eq!(returns, vec![BorshToken::Bool(false)]);
@@ -214,7 +211,6 @@ fn transfer_succeeds() {
                 value: BigInt::from(102u8),
             },
         ],
-        None,
     );
 
     assert_eq!(vm.account_data.get_mut(&new).unwrap().lamports, 107);
@@ -260,7 +256,6 @@ fn transfer_fails_not_enough() {
                 value: BigInt::from(104u8),
             },
         ],
-        None,
     );
     std::println!("{:?}", res);
     assert!(res.is_err());
@@ -303,7 +298,6 @@ fn transfer_fails_overflow() {
                 value: BigInt::from(104u8),
             },
         ],
-        None,
     );
     assert!(res.is_err());
 }
@@ -341,7 +335,7 @@ fn fallback() {
         vm.stack[0].abi = Some(abi);
     }
 
-    vm.function("extinct", &[], None);
+    vm.function("extinct", &[]);
 
     assert_eq!(vm.logs, "fallback");
 }
@@ -383,7 +377,6 @@ fn value_overflows() {
                 value: BigInt::from(u64::MAX as u128 + 1),
             },
         ],
-        None,
     );
     assert_eq!(res.ok(), Some(4294967296));
 
@@ -396,7 +389,6 @@ fn value_overflows() {
                 value: BigInt::from(u128::MAX),
             },
         ],
-        None,
     );
     assert_eq!(res.ok(), Some(4294967296));
 
@@ -409,7 +401,6 @@ fn value_overflows() {
                 value: BigInt::from(102u8),
             },
         ],
-        None,
     );
 
     assert_eq!(returns, vec![BorshToken::Bool(false)]);

tests/solana_tests/builtin.rs

@@ -32,7 +32,7 @@ fn builtins() {
 
     vm.constructor("timestamp", &[]);
 
-    let returns = vm.function("mr_now", &[], None);
+    let returns = vm.function("mr_now", &[]);
 
     assert_eq!(
         returns,
@@ -42,7 +42,7 @@ fn builtins() {
         }]
     );
 
-    let returns = vm.function("mr_slot", &[], None);
+    let returns = vm.function("mr_slot", &[]);
 
     assert_eq!(
         returns,
@@ -52,7 +52,7 @@ fn builtins() {
         }]
     );
 
-    let returns = vm.function("mr_blocknumber", &[], None);
+    let returns = vm.function("mr_blocknumber", &[]);
 
     assert_eq!(
         returns,
@@ -68,7 +68,6 @@ fn builtins() {
             width: 32,
             value: BigInt::from(0xdeadcafeu32),
         }],
-        None,
     );
 
     if let BorshToken::Bytes(v) = &returns[0] {
@@ -82,7 +81,7 @@ fn builtins() {
         )]
     );
 
-    let returns = vm.function("sig", &[], None);
+    let returns = vm.function("sig", &[]);
 
     if let BorshToken::FixedBytes(v) = &returns[0] {
         println!("{}", hex::encode(v));
@@ -95,7 +94,7 @@ fn builtins() {
         )]
     );
 
-    let returns = vm.function("prog", &[], None);
+    let returns = vm.function("prog", &[]);
 
     assert_eq!(
         returns,
@@ -141,7 +140,7 @@ fn pda() {
 
     vm.constructor("pda", &[]);
 
-    let returns = vm.function("create_pda", &[BorshToken::Bool(true)], None);
+    let returns = vm.function("create_pda", &[BorshToken::Bool(true)]);
 
     if let BorshToken::FixedBytes(bs) = &returns[0] {
         assert_eq!(
@@ -152,7 +151,7 @@ fn pda() {
         panic!("{:?} not expected", returns);
     }
 
-    let returns = vm.function("create_pda", &[BorshToken::Bool(false)], None);
+    let returns = vm.function("create_pda", &[BorshToken::Bool(false)]);
 
     if let BorshToken::FixedBytes(bs) = &returns[0] {
         assert_eq!(
@@ -169,7 +168,6 @@ fn pda() {
             BorshToken::Bytes(b"Talking".to_vec()),
             BorshToken::Bytes(b"Squirrels".to_vec()),
         ],
-        None,
     );
 
     if let BorshToken::FixedBytes(bs) = &returns[0] {
@@ -181,7 +179,7 @@ fn pda() {
         panic!("{:?} not expected", returns);
     }
 
-    let returns = vm.function("create_pda2_bump", &[BorshToken::Bool(true)], None);
+    let returns = vm.function("create_pda2_bump", &[BorshToken::Bool(true)]);
 
     assert_eq!(returns[1], BorshToken::FixedBytes(vec![255]));
 
@@ -194,7 +192,7 @@ fn pda() {
         panic!("{:?} not expected", returns);
     }
 
-    let returns = vm.function("create_pda2_bump", &[BorshToken::Bool(false)], None);
+    let returns = vm.function("create_pda2_bump", &[BorshToken::Bool(false)]);
 
     assert_eq!(returns[1], BorshToken::FixedBytes(vec![255]));
 
@@ -225,7 +223,7 @@ fn test_string_bytes_buffer_write() {
         "#,
     );
     vm.constructor("Testing", &[]);
-    let returns = vm.function("testStringAndBytes", &[], None);
+    let returns = vm.function("testStringAndBytes", &[]);
     let bytes = returns[0].clone().into_bytes().unwrap();
 
     assert_eq!(bytes.len(), 9);
@@ -250,7 +248,7 @@ fn out_of_bounds_bytes_write() {
     );
 
     vm.constructor("Testing", &[]);
-    let _ = vm.function("testBytesOut", &[], None);
+    let _ = vm.function("testBytesOut", &[]);
 }
 
 #[test]
@@ -270,5 +268,5 @@ fn out_of_bounds_string_write() {
     );
 
     vm.constructor("Testing", &[]);
-    let _ = vm.function("testStringOut", &[], None);
+    let _ = vm.function("testStringOut", &[]);
 }

tests/solana_tests/call.rs

@@ -30,7 +30,7 @@ fn simple_external_call() {
 
     vm.constructor("bar1", &[]);
 
-    vm.function("test_bar", &[BorshToken::String(String::from("yo"))], None);
+    vm.function("test_bar", &[BorshToken::String(String::from("yo"))]);
 
     assert_eq!(vm.logs, "bar1 says: yo");
 
@@ -45,14 +45,13 @@ fn simple_external_call() {
     vm.function(
         "test_bar",
         &[BorshToken::String(String::from("uncle beau"))],
-        None,
     );
 
     assert_eq!(vm.logs, "bar0 says: uncle beau");
 
     vm.logs.truncate(0);
 
-    vm.function("test_other", &[BorshToken::Address(bar1_account)], None);
+    vm.function("test_other", &[BorshToken::Address(bar1_account)]);
 
     assert_eq!(vm.logs, "bar1 says: cross contract call");
 }
@@ -82,7 +81,6 @@ fn external_call_with_returns() {
             width: 64,
             value: BigInt::from(21),
         }],
-        None,
     );
 
     assert_eq!(
@@ -99,7 +97,7 @@ fn external_call_with_returns() {
 
     vm.constructor("bar0", &[]);
 
-    let res = vm.function("test_other", &[BorshToken::Address(bar1_account)], None);
+    let res = vm.function("test_other", &[BorshToken::Address(bar1_account)]);
 
     assert_eq!(
         res,
@@ -142,7 +140,6 @@ fn external_raw_call_with_returns() {
             width: 64,
             value: BigInt::from(21u8),
         }],
-        None,
     );
 
     assert_eq!(
@@ -159,7 +156,7 @@ fn external_raw_call_with_returns() {
 
     vm.constructor("bar0", &[]);
 
-    let res = vm.function("test_other", &[BorshToken::Address(bar1_account)], None);
+    let res = vm.function("test_other", &[BorshToken::Address(bar1_account)]);
 
     assert_eq!(
         res,
@@ -192,7 +189,7 @@ fn call_external_func_type() {
 
     vm.constructor("testing", &[]);
 
-    let res = vm.function("doTest", &[], None);
+    let res = vm.function("doTest", &[]);
 
     assert_eq!(
         res,
@@ -224,10 +221,6 @@ fn external_call_with_string_returns() {
                 address a = x.who_am_i();
                 assert(a == address(x));
             }
-
-            function test_sender(bar1 x) public returns (address) {
-                return x.who_is_sender();
-            }
         }
 
         contract bar1 {
@@ -238,10 +231,6 @@ fn external_call_with_string_returns() {
             function who_am_i() public returns (address) {
                 return address(this);
             }
-
-            function who_is_sender() public returns (address) {
-                return msg.sender;
-            }
         }"#,
     );
 
@@ -253,7 +242,6 @@ fn external_call_with_string_returns() {
             width: 64,
             value: BigInt::from(22u8),
         }],
-        None,
     );
 
     assert_eq!(res, vec![BorshToken::String(String::from("foo:22"))]);
@@ -264,17 +252,11 @@ fn external_call_with_string_returns() {
 
     vm.constructor("bar0", &[]);
 
-    let bar0_account = vm.stack[0].data;
-
-    let res = vm.function("test_other", &[BorshToken::Address(bar1_account)], None);
+    let res = vm.function("test_other", &[BorshToken::Address(bar1_account)]);
 
     assert_eq!(res, vec![BorshToken::String(String::from("foo:7"))]);
 
-    vm.function("test_this", &[BorshToken::Address(bar1_account)], None);
-
-    let res = vm.function("test_sender", &[BorshToken::Address(bar1_account)], None);
-
-    assert_eq!(res[0], BorshToken::FixedBytes(bar0_account.to_vec()));
+    vm.function("test_this", &[BorshToken::Address(bar1_account)]);
 }
 
 #[test]
@@ -309,7 +291,6 @@ fn encode_call() {
             width: 64,
             value: BigInt::from(21u8),
         }],
-        None,
     );
 
     assert_eq!(
@@ -326,7 +307,7 @@ fn encode_call() {
 
     vm.constructor("bar0", &[]);
 
-    let res = vm.function("test_other", &[BorshToken::Address(bar1_account)], None);
+    let res = vm.function("test_other", &[BorshToken::Address(bar1_account)]);
 
     assert_eq!(
         res,
@@ -368,7 +349,7 @@ fn internal_function_storage() {
 
     vm.constructor("ft", &[]);
 
-    let res = vm.function("set_op", &[BorshToken::Bool(true)], None);
+    let res = vm.function("set_op", &[BorshToken::Bool(true)]);
 
     assert_eq!(res, vec![]);
 
@@ -384,7 +365,6 @@ fn internal_function_storage() {
                 value: BigInt::from(5u8),
             },
         ],
-        None,
     );
 
     assert_eq!(
@@ -395,7 +375,7 @@ fn internal_function_storage() {
         },]
     );
 
-    let res = vm.function("set_op", &[BorshToken::Bool(false)], None);
+    let res = vm.function("set_op", &[BorshToken::Bool(false)]);
 
     assert_eq!(res, vec![]);
 
@@ -411,7 +391,6 @@ fn internal_function_storage() {
                 value: BigInt::from(5u8),
             },
         ],
-        None,
     );
 
     assert_eq!(
@@ -516,7 +495,6 @@ fn raw_call_accounts() {
             BorshToken::Address(b"quinquagintaquadringentilliardth".to_owned()),
             BorshToken::Address(b"quinquagintaquadringentillionths".to_owned()),
         ],
-        None,
     );
 }
 
@@ -565,5 +543,5 @@ fn pda() {
 
     vm.call_params_check.insert(token, test_args);
 
-    vm.function("test", &[], None);
+    vm.function("test", &[]);
 }

tests/solana_tests/constant.rs

@@ -22,7 +22,7 @@ fn constant() {
 
     vm.constructor("foo", &[]);
 
-    let returns = vm.function("f", &[], None);
+    let returns = vm.function("f", &[]);
     assert_eq!(
         returns,
         vec![BorshToken::Uint {
@@ -48,7 +48,7 @@ fn constant() {
 
     vm.constructor("foo", &[]);
 
-    let returns = vm.function("f", &[], None);
+    let returns = vm.function("f", &[]);
     assert_eq!(
         returns,
         vec![BorshToken::Uint {

tests/solana_tests/create_contract.rs

@@ -61,7 +61,6 @@ fn simple_create_contract_no_seed() {
     let bar1 = vm.function(
         "test_other",
         &[BorshToken::Address(acc), BorshToken::Address(payer)],
-        None,
     );
 
     assert_eq!(vm.logs, "bar1 says: yo from bar0");
@@ -73,7 +72,6 @@ fn simple_create_contract_no_seed() {
     vm.function(
         "call_bar1_at_address",
         &[bar1[0].clone(), BorshToken::String(String::from("xywoleh"))],
-        None,
     );
 
     assert_eq!(vm.logs, "Hello xywoleh");
@@ -124,7 +122,6 @@ fn simple_create_contract() {
     let bar1 = vm.function(
         "test_other",
         &[BorshToken::Address(seed.0), BorshToken::Address(payer)],
-        None,
     );
 
     assert_eq!(vm.logs, "bar1 says: yo from bar0");
@@ -136,7 +133,6 @@ fn simple_create_contract() {
     vm.function(
         "call_bar1_at_address",
         &[bar1[0].clone(), BorshToken::String(String::from("xywoleh"))],
-        None,
     );
 
     assert_eq!(vm.logs, "Hello xywoleh");
@@ -199,7 +195,7 @@ fn create_contract_with_payer() {
 
     vm.constructor("x", &[BorshToken::Address(payer)]);
 
-    let ret = vm.function("f", &[], None);
+    let ret = vm.function("f", &[]);
 
     assert_eq!(
         ret[0],
@@ -245,7 +241,7 @@ fn missing_contract() {
 
     let missing = account_new();
 
-    let res = vm.function_must_fail("test_other", &[BorshToken::Address(missing)], None);
+    let res = vm.function_must_fail("test_other", &[BorshToken::Address(missing)]);
     assert_eq!(res, Ok(64424509440));
 }
 
@@ -287,7 +283,6 @@ fn two_contracts() {
     let _bar1 = vm.function(
         "test_other",
         &[BorshToken::Address(seed1.0), BorshToken::Address(seed2.0)],
-        None,
     );
 
     assert_eq!(vm.logs, "bar1 says: yo from bar0bar1 says: hi from bar0");
@@ -347,7 +342,7 @@ fn account_with_space() {
 
     assert_eq!(vm.account_data.get_mut(&data).unwrap().data.len(), 3 * 102);
 
-    let ret = vm.function("hello", &[], None);
+    let ret = vm.function("hello", &[]);
 
     assert_eq!(ret[0], BorshToken::Bool(true));
 }
@@ -388,7 +383,7 @@ fn account_with_seed() {
         511 + 102
     );
 
-    let ret = vm.function("hello", &[], None);
+    let ret = vm.function("hello", &[]);
 
     assert_eq!(ret[0], BorshToken::Bool(true));
 }
@@ -439,7 +434,7 @@ fn account_with_seed_bump() {
         511 + 102
     );
 
-    let ret = vm.function("hello", &[], None);
+    let ret = vm.function("hello", &[]);
 
     assert_eq!(ret[0], BorshToken::Bool(true));
 }
@@ -478,7 +473,7 @@ fn account_with_seed_bump_literals() {
         8192
     );
 
-    let ret = vm.function("hello", &[], None);
+    let ret = vm.function("hello", &[]);
 
     assert_eq!(ret[0], BorshToken::Bool(true));
 }
@@ -524,7 +519,6 @@ fn create_child() {
     vm.function(
         "create_child",
         &[BorshToken::Address(seed.0), BorshToken::Address(payer)],
-        None,
     );
 
     assert_eq!(

tests/solana_tests/destructure.rs

@@ -20,7 +20,7 @@ fn conditional_destructure() {
 
     vm.constructor("foo", &[]);
 
-    let returns = vm.function("f", &[BorshToken::Bool(true), BorshToken::Bool(true)], None);
+    let returns = vm.function("f", &[BorshToken::Bool(true), BorshToken::Bool(true)]);
 
     assert_eq!(
         returns,
@@ -36,11 +36,7 @@ fn conditional_destructure() {
         ]
     );
 
-    let returns = vm.function(
-        "f",
-        &[BorshToken::Bool(true), BorshToken::Bool(false)],
-        None,
-    );
+    let returns = vm.function("f", &[BorshToken::Bool(true), BorshToken::Bool(false)]);
 
     assert_eq!(
         returns,
@@ -56,11 +52,7 @@ fn conditional_destructure() {
         ]
     );
 
-    let returns = vm.function(
-        "f",
-        &[BorshToken::Bool(false), BorshToken::Bool(false)],
-        None,
-    );
+    let returns = vm.function("f", &[BorshToken::Bool(false), BorshToken::Bool(false)]);
 
     assert_eq!(
         returns,
@@ -76,11 +68,7 @@ fn conditional_destructure() {
         ]
     );
 
-    let returns = vm.function(
-        "f",
-        &[BorshToken::Bool(false), BorshToken::Bool(true)],
-        None,
-    );
+    let returns = vm.function("f", &[BorshToken::Bool(false), BorshToken::Bool(true)]);
 
     assert_eq!(
         returns,
@@ -115,7 +103,7 @@ fn casting_destructure() {
 
     vm.constructor("foo", &[]);
 
-    let returns = vm.function("f", &[], None);
+    let returns = vm.function("f", &[]);
 
     assert_eq!(
         returns,
@@ -143,7 +131,7 @@ fn casting_destructure() {
 
     vm.constructor("foo", &[]);
 
-    let returns = vm.function("f", &[], None);
+    let returns = vm.function("f", &[]);
 
     assert_eq!(returns, vec![BorshToken::String(String::from("Hello")),]);
 }

tests/solana_tests/events.rs

@@ -25,7 +25,7 @@ fn simple_event() {
 
     vm.constructor("c", &[]);
 
-    vm.function("go", &[], None);
+    vm.function("go", &[]);
 
     let log = vm.events();
 
@@ -81,7 +81,7 @@ fn less_simple_event() {
 
     vm.constructor("c", &[]);
 
-    vm.function("go", &[], None);
+    vm.function("go", &[]);
 
     let log = vm.events();
     assert_eq!(log.len(), 1);

tests/solana_tests/expressions.rs

@@ -22,7 +22,7 @@ fn interfaceid() {
 
     vm.constructor("foo", &[]);
 
-    let returns = vm.function("get", &[], None);
+    let returns = vm.function("get", &[]);
 
     assert_eq!(
         returns,
@@ -47,7 +47,7 @@ fn write_buffer() {
             function test2() public returns (bytes) {
                 bytes bs = new bytes(34);
                 bs.writeUint16LE(0x4142, 0);
-                bs.writeAddress(msg.sender, 2);
+                bs.writeAddress(tx.program_id, 2);
                 return bs;
             }
 
@@ -61,7 +61,7 @@ fn write_buffer() {
 
     vm.constructor("foo", &[]);
 
-    let returns = vm.function("test1", &[], None);
+    let returns = vm.function("test1", &[]);
 
     assert_eq!(
         returns,
@@ -70,14 +70,14 @@ fn write_buffer() {
         )]
     );
 
-    let returns = vm.function("test2", &[], None);
+    let returns = vm.function("test2", &[]);
 
     let mut buf = vec![0x42u8, 0x41u8];
-    buf.extend_from_slice(&vm.origin);
+    buf.extend_from_slice(&vm.stack[0].program);
 
     assert_eq!(returns, vec![BorshToken::Bytes(buf)]);
 
-    let res = vm.function_must_fail("test3", &[], None);
+    let res = vm.function_must_fail("test3", &[]);
     assert_eq!(res, Ok(4294967296));
 }
 
@@ -103,7 +103,6 @@ fn read_buffer() {
         &[BorshToken::Bytes(
             [0xbc, 0xbc, 0xbd, 0xbe, 8, 7, 6, 5, 4, 3, 2, 1].to_vec(),
         )],
-        None,
     );
 
     assert_eq!(
@@ -125,14 +124,13 @@ fn read_buffer() {
         &[BorshToken::Bytes(
             [0xbc, 0xbc, 0xbd, 0xbe, 8, 7, 6, 5, 4, 3, 2].to_vec(),
         )],
-        None,
     );
     assert_eq!(res, Ok(4294967296));
 
     let mut buf = vec![0x42u8, 0x41u8];
     buf.extend_from_slice(&vm.origin);
 
-    let returns = vm.function("test2", &[BorshToken::Bytes(buf.clone())], None);
+    let returns = vm.function("test2", &[BorshToken::Bytes(buf.clone())]);
 
     assert_eq!(
         returns,
@@ -147,7 +145,7 @@ fn read_buffer() {
 
     buf.pop();
 
-    let res = vm.function_must_fail("test2", &[BorshToken::Bytes(buf)], None);
+    let res = vm.function_must_fail("test2", &[BorshToken::Bytes(buf)]);
     assert_eq!(res, Ok(4294967296));
 }
 
@@ -171,7 +169,6 @@ fn bytes_compare() {
     let returns = vm.function(
         "test1",
         &[BorshToken::FixedBytes([0xbc, 0xbc, 0xbd, 0xbe].to_vec())],
-        None,
     );
 
     assert_eq!(returns, vec![BorshToken::Bool(true)]);
@@ -179,7 +176,6 @@ fn bytes_compare() {
     let returns = vm.function(
         "test2",
         &[BorshToken::FixedBytes([0xbc, 0xbc, 0xbd, 0xbe].to_vec())],
-        None,
     );
 
     assert_eq!(returns, vec![BorshToken::Bool(false)]);
@@ -216,7 +212,6 @@ fn assignment_in_ternary() {
                     value: BigInt::from(right),
                 },
             ],
-            None,
         );
 
         assert_eq!(
@@ -242,7 +237,7 @@ fn power() {
 
     vm.constructor("foo", &[]);
 
-    let returns = vm.function("power", &[], None);
+    let returns = vm.function("power", &[]);
 
     assert_eq!(
         returns,

tests/solana_tests/hash.rs

@@ -16,7 +16,7 @@ fn constants_hash_tests() {
     );
 
     runtime.constructor("tester", &[]);
-    runtime.function("test", &[], None);
+    runtime.function("test", &[]);
 
     let mut runtime = build_solidity(
         r##"
@@ -30,7 +30,7 @@ fn constants_hash_tests() {
     );
 
     runtime.constructor("tester", &[]);
-    runtime.function("test", &[], None);
+    runtime.function("test", &[]);
 
     let mut runtime = build_solidity(
         r##"
@@ -44,7 +44,7 @@ fn constants_hash_tests() {
     );
 
     runtime.constructor("tester", &[]);
-    runtime.function("test", &[], None);
+    runtime.function("test", &[]);
 }
 
 #[test]
@@ -61,11 +61,7 @@ fn hash_tests() {
     );
 
     runtime.constructor("tester", &[]);
-    let hash = runtime.function(
-        "test",
-        &[BorshToken::Bytes(b"Hello, World!".to_vec())],
-        None,
-    );
+    let hash = runtime.function("test", &[BorshToken::Bytes(b"Hello, World!".to_vec())]);
 
     assert_eq!(
         hash,
@@ -86,11 +82,7 @@ fn hash_tests() {
     );
 
     runtime.constructor("tester", &[]);
-    let hash = runtime.function(
-        "test",
-        &[BorshToken::Bytes(b"Hello, World!".to_vec())],
-        None,
-    );
+    let hash = runtime.function("test", &[BorshToken::Bytes(b"Hello, World!".to_vec())]);
 
     assert_eq!(
         hash,
@@ -112,11 +104,7 @@ fn hash_tests() {
     );
 
     runtime.constructor("tester", &[]);
-    let hash = runtime.function(
-        "test",
-        &[BorshToken::Bytes(b"Hello, World!".to_vec())],
-        None,
-    );
+    let hash = runtime.function("test", &[BorshToken::Bytes(b"Hello, World!".to_vec())]);
 
     assert_eq!(
         hash,

tests/solana_tests/mappings.rs

@@ -40,7 +40,6 @@ fn simple_mapping() {
                     value: BigInt::from(300331 + i),
                 },
             ],
-            None,
         );
     }
 
@@ -51,7 +50,6 @@ fn simple_mapping() {
                 width: 64,
                 value: BigInt::from(102 + i),
             }],
-            None,
         );
 
         assert_eq!(
@@ -69,7 +67,6 @@ fn simple_mapping() {
             width: 64,
             value: BigInt::from(101u8),
         }],
-        None,
     );
 
     assert_eq!(
@@ -86,7 +83,6 @@ fn simple_mapping() {
             width: 64,
             value: BigInt::from(104u8),
         }],
-        None,
     );
 
     for i in 0..10 {
@@ -96,7 +92,6 @@ fn simple_mapping() {
                 width: 64,
                 value: BigInt::from(102 + i),
             }],
-            None,
         );
 
         if 102 + i != 104 {
@@ -159,7 +154,7 @@ fn less_simple_mapping() {
                 value: BigInt::from(12313132131321312311213131u128)
             },
             BorshToken::String(String::from("This is a string which should be a little longer than 32 bytes so we the the abi encoder")),
-        ],  None
+        ],
     );
 
     vm.function(
@@ -174,7 +169,6 @@ fn less_simple_mapping() {
                 value: BigInt::from(102u8),
             },
         ],
-        None,
     );
 
     let returns = vm.function(
@@ -183,7 +177,6 @@ fn less_simple_mapping() {
             width: 256,
             value: BigInt::from(12313132131321312311213131u128),
         }],
-        None,
     );
 
     assert_eq!(
@@ -237,7 +230,7 @@ fn string_mapping() {
         &[
             BorshToken::String(String::from("a")),
             BorshToken::String(String::from("This is a string which should be a little longer than 32 bytes so we the the abi encoder")),
-        ], None
+        ],
     );
 
     vm.function(
@@ -249,10 +242,9 @@ fn string_mapping() {
                 value: BigInt::from(102u8),
             },
         ],
-        None,
     );
 
-    let returns = vm.function("get", &[BorshToken::String(String::from("a"))], None);
+    let returns = vm.function("get", &[BorshToken::String(String::from("a"))]);
 
     assert_eq!(
         returns,
@@ -300,19 +292,18 @@ fn contract_mapping() {
         &[
             index.clone(),
             BorshToken::String(String::from("This is a string which should be a little longer than 32 bytes so we the the abi encoder")),
-        ], None
-    );
+        ], );
 
-    let returns = vm.function("get", &[index.clone()], None);
+    let returns = vm.function("get", &[index.clone()]);
 
     assert_eq!(
         returns,
         vec![BorshToken::String(String::from("This is a string which should be a little longer than 32 bytes so we the the abi encoder"))]
     );
 
-    vm.function("rm", &[index.clone()], None);
+    vm.function("rm", &[index.clone()]);
 
-    let returns = vm.function("get", &[index], None);
+    let returns = vm.function("get", &[index]);
 
     assert_eq!(returns, vec![BorshToken::String(String::from(""))]);
 }
@@ -342,7 +333,6 @@ fn mapping_in_mapping() {
             },
             BorshToken::FixedBytes(vec![0x98]),
         ],
-        None,
     );
 
     let returns = vm.function(
@@ -354,7 +344,6 @@ fn mapping_in_mapping() {
                 value: BigInt::from(102u8),
             },
         ],
-        None,
     );
 
     assert_eq!(returns, vec![BorshToken::FixedBytes(vec![0x98])]);
@@ -368,7 +357,6 @@ fn mapping_in_mapping() {
                 value: BigInt::from(103u8),
             },
         ],
-        None,
     );
 
     assert_eq!(returns, vec![BorshToken::FixedBytes(vec![0])]);
@@ -382,7 +370,6 @@ fn mapping_in_mapping() {
                 value: BigInt::from(102u8),
             },
         ],
-        None,
     );
 
     assert_eq!(returns, vec![BorshToken::FixedBytes(vec![0])]);
@@ -428,8 +415,7 @@ fn sparse_array() {
                 value: BigInt::from(909090909u64)
             },
             BorshToken::String(String::from("This is a string which should be a little longer than 32 bytes so we the the abi encoder")),
-        ], None
-    );
+        ], );
 
     vm.function(
         "add_int",
@@ -443,7 +429,6 @@ fn sparse_array() {
                 value: BigInt::from(102u8),
             },
         ],
-        None,
     );
 
     let returns = vm.function(
@@ -452,7 +437,6 @@ fn sparse_array() {
             width: 256,
             value: BigInt::from(909090909u64),
         }],
-        None,
     );
 
     assert_eq!(
@@ -509,8 +493,7 @@ fn massive_sparse_array() {
                 value: BigInt::from(786868768768678687686877u128)
             },
             BorshToken::String(String::from("This is a string which should be a little longer than 32 bytes so we the the abi encoder")),
-        ], None
-    );
+        ], );
 
     vm.function(
         "add_int",
@@ -524,7 +507,6 @@ fn massive_sparse_array() {
                 value: BigInt::from(102u8),
             },
         ],
-        None,
     );
 
     let returns = vm.function(
@@ -533,7 +515,6 @@ fn massive_sparse_array() {
             width: 256,
             value: BigInt::from(786868768768678687686877u128),
         }],
-        None,
     );
 
     assert_eq!(
@@ -592,11 +573,10 @@ fn mapping_in_dynamic_array() {
             width: 64,
             value: BigInt::from(2147483647),
         }],
-        None,
     );
 
-    vm.function("push", &[], None);
-    vm.function("push", &[], None);
+    vm.function("push", &[]);
+    vm.function("push", &[]);
 
     for array_no in 0..2 {
         for i in 0..10 {
@@ -616,7 +596,6 @@ fn mapping_in_dynamic_array() {
                         value: BigInt::from(300331 + i),
                     },
                 ],
-                None,
             );
         }
     }
@@ -635,7 +614,6 @@ fn mapping_in_dynamic_array() {
                         value: BigInt::from(102 + i + array_no * 500),
                     },
                 ],
-                None,
             );
 
             assert_eq!(
@@ -660,7 +638,6 @@ fn mapping_in_dynamic_array() {
                 value: BigInt::from(101u8),
             },
         ],
-        None,
     );
 
     assert_eq!(
@@ -683,7 +660,6 @@ fn mapping_in_dynamic_array() {
                 value: BigInt::from(104u8),
             },
         ],
-        None,
     );
 
     for i in 0..10 {
@@ -699,7 +675,6 @@ fn mapping_in_dynamic_array() {
                     value: BigInt::from(102 + i),
                 },
             ],
-            None,
         );
 
         if 102 + i != 104 {
@@ -721,7 +696,7 @@ fn mapping_in_dynamic_array() {
         }
     }
 
-    let returns = vm.function("length", &[], None);
+    let returns = vm.function("length", &[]);
     assert_eq!(
         returns,
         vec![BorshToken::Uint {
@@ -730,9 +705,9 @@ fn mapping_in_dynamic_array() {
         }]
     );
 
-    vm.function("pop", &[], None);
+    vm.function("pop", &[]);
 
-    let returns = vm.function("length", &[], None);
+    let returns = vm.function("length", &[]);
     assert_eq!(
         returns,
         vec![BorshToken::Uint {
@@ -741,9 +716,9 @@ fn mapping_in_dynamic_array() {
         }]
     );
 
-    vm.function("pop", &[], None);
+    vm.function("pop", &[]);
 
-    let returns = vm.function("length", &[], None);
+    let returns = vm.function("length", &[]);
     assert_eq!(
         returns,
         vec![BorshToken::Uint {
@@ -752,7 +727,7 @@ fn mapping_in_dynamic_array() {
         }]
     );
 
-    let returns = vm.function("number", &[], None);
+    let returns = vm.function("number", &[]);
 
     assert_eq!(
         returns,
@@ -809,11 +784,10 @@ fn mapping_in_struct_in_dynamic_array() {
             width: 64,
             value: BigInt::from(2147483647),
         }],
-        None,
     );
 
-    vm.function("push", &[], None);
-    vm.function("push", &[], None);
+    vm.function("push", &[]);
+    vm.function("push", &[]);
 
     for array_no in 0..2 {
         for i in 0..10 {
@@ -833,7 +807,6 @@ fn mapping_in_struct_in_dynamic_array() {
                         value: BigInt::from(300331 + i),
                     },
                 ],
-                None,
             );
         }
     }
@@ -852,7 +825,6 @@ fn mapping_in_struct_in_dynamic_array() {
                         value: BigInt::from(102 + i + array_no * 500),
                     },
                 ],
-                None,
             );
 
             assert_eq!(
@@ -877,7 +849,6 @@ fn mapping_in_struct_in_dynamic_array() {
                 value: BigInt::from(101u8),
             },
         ],
-        None,
     );
 
     assert_eq!(
@@ -900,7 +871,6 @@ fn mapping_in_struct_in_dynamic_array() {
                 value: BigInt::from(104u8),
             },
         ],
-        None,
     );
 
     for i in 0..10 {
@@ -916,7 +886,6 @@ fn mapping_in_struct_in_dynamic_array() {
                     value: BigInt::from(102 + i),
                 },
             ],
-            None,
         );
 
         if 102 + i != 104 {
@@ -938,10 +907,10 @@ fn mapping_in_struct_in_dynamic_array() {
         }
     }
 
-    vm.function("pop", &[], None);
-    vm.function("pop", &[], None);
+    vm.function("pop", &[]);
+    vm.function("pop", &[]);
 
-    let returns = vm.function("number", &[], None);
+    let returns = vm.function("number", &[]);
 
     assert_eq!(
         returns,
@@ -965,8 +934,8 @@ contract DeleteTest {
 
     mapping(uint => data_struct) example;
 
-    function addData() public  {
-        data_struct dt = data_struct({addr1: address(this), addr2: msg.sender});
+    function addData(address sender) public  {
+        data_struct dt = data_struct({addr1: address(this), addr2: sender});
         uint id = 1;
         example[id] = dt;
     }
@@ -984,10 +953,12 @@ contract DeleteTest {
         "#,
     );
 
+    let sender = account_new();
+
     vm.constructor("DeleteTest", &[]);
-    let _ = vm.function("addData", &[], None);
-    let _ = vm.function("deltest", &[], None);
-    let returns = vm.function("get", &[], None);
+    let _ = vm.function("addData", &[BorshToken::Address(sender)]);
+    let _ = vm.function("deltest", &[]);
+    let returns = vm.function("get", &[]);
     assert_eq!(
         returns,
         vec![BorshToken::Tuple(vec![
@@ -1022,11 +993,11 @@ contract CrowdFunding {
     mapping (uint => Campaign) campaigns;
 
 
-function newCampaign() public returns (uint campaignID) {
+function newCampaign(address sender) public returns (uint campaignID) {
     campaignID = numCampaigns++;
     Campaign storage _campaign = campaigns[campaignID];
-    _campaign.funders[0] = Funder(msg.sender, 100);
-    _campaign.arr_mp[1][0] = Funder(msg.sender, 105);
+    _campaign.funders[0] = Funder(sender, 100);
+    _campaign.arr_mp[1][0] = Funder(sender, 105);
 }
 
 function getAmt() public view returns (uint) {
@@ -1043,9 +1014,11 @@ function getArrAmt() public view returns (uint) {
         "#,
     );
 
+    let sender = account_new();
+
     vm.constructor("CrowdFunding", &[]);
 
-    let ret = vm.function("newCampaign", &[], None);
+    let ret = vm.function("newCampaign", &[BorshToken::Address(sender)]);
 
     assert_eq!(
         ret,
@@ -1055,7 +1028,7 @@ function getArrAmt() public view returns (uint) {
         }]
     );
 
-    let ret = vm.function("getAmt", &[], None);
+    let ret = vm.function("getAmt", &[]);
     assert_eq!(
         ret,
         vec![BorshToken::Uint {
@@ -1064,7 +1037,7 @@ function getArrAmt() public view returns (uint) {
         }]
     );
 
-    let ret = vm.function("getArrAmt", &[], None);
+    let ret = vm.function("getArrAmt", &[]);
     assert_eq!(
         ret,
         vec![BorshToken::Uint {

tests/solana_tests/math.rs

@@ -53,7 +53,6 @@ fn safe_math() {
                 value: BigInt::from_str("4000000000000000000").unwrap(),
             },
         ],
-        None,
     );
 
     assert_eq!(
@@ -76,7 +75,6 @@ fn safe_math() {
                 value: BigInt::from_str("4000000000000000000").unwrap(),
             },
         ],
-        None,
     );
 
     assert_eq!(
@@ -99,7 +97,6 @@ fn safe_math() {
                 value: BigInt::from_str("1000000000000000000").unwrap(),
             },
         ],
-        None,
     );
 
     assert_eq!(
@@ -122,7 +119,6 @@ fn safe_math() {
                 value: BigInt::from_str("400000000000000000000000000000000000000").unwrap(),
             },
         ],
-        None,
     );
 
     assert_ne!(res, Ok(0));
@@ -139,7 +135,6 @@ fn safe_math() {
                 value: BigInt::from_str("100000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap(),
             },
         ],
-       None,
     );
 
     assert_ne!(res, Ok(0));
@@ -156,7 +151,6 @@ fn safe_math() {
                 value: BigInt::from_str("4000000000000000000").unwrap(),
             },
         ],
-        None,
     );
 
     assert_ne!(res, Ok(0));

tests/solana_tests/metas.rs

@@ -0,0 +1,51 @@
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::{account_new, build_solidity, AccountState, BorshToken};
+
+#[test]
+fn use_authority() {
+    let mut vm = build_solidity(include_str!("../../docs/examples/solana/use_authority.sol"));
+
+    let authority = account_new();
+
+    vm.account_data.insert(
+        authority,
+        AccountState {
+            data: vec![],
+            owner: Some([0u8; 32]),
+            lamports: 0,
+        },
+    );
+
+    vm.constructor("AuthorityExample", &[BorshToken::Address(authority)]);
+
+    let res = vm.function_must_fail("inc", &[]).unwrap();
+    assert!(res != 0);
+
+    let res = vm.function("get", &[]);
+    assert_eq!(
+        res,
+        vec![BorshToken::Uint {
+            width: 64,
+            value: 0.into()
+        }]
+    );
+
+    let mut metas = vm.default_metas();
+
+    // "sign" the transaction with the authority
+    if let Some(meta) = metas.iter_mut().find(|e| e.pubkey.0 == authority) {
+        meta.is_signer = true;
+    }
+
+    vm.function_metas(&metas, "inc", &[]);
+
+    let res = vm.function("get", &[]);
+    assert_eq!(
+        res,
+        vec![BorshToken::Uint {
+            width: 64,
+            value: 1.into()
+        }]
+    );
+}

tests/solana_tests/mod.rs

@@ -17,6 +17,7 @@ mod expressions;
 mod hash;
 mod mappings;
 mod math;
+mod metas;
 mod modifiers;
 mod primitives;
 mod rational;

tests/solana_tests/modifiers.rs

@@ -30,7 +30,7 @@ fn returns_and_phis_needed() {
 
     vm.constructor("c", &[]);
 
-    let returns = vm.function("func", &[BorshToken::Bool(false)], None);
+    let returns = vm.function("func", &[BorshToken::Bool(false)]);
 
     assert_eq!(
         returns,
@@ -43,7 +43,7 @@ fn returns_and_phis_needed() {
         ]
     );
 
-    let returns = vm.function("func", &[BorshToken::Bool(true)], None);
+    let returns = vm.function("func", &[BorshToken::Bool(true)]);
 
     assert_eq!(
         returns,

tests/solana_tests/primitives.rs

@@ -30,7 +30,7 @@ fn assert_false() {
 
     vm.constructor("foo", &[]);
 
-    vm.function("assert_fails", &[], None);
+    vm.function("assert_fails", &[]);
 }
 
 #[test]
@@ -47,7 +47,7 @@ fn assert_true() {
 
     vm.constructor("foo", &[]);
 
-    vm.function("assert_fails", &[], None);
+    vm.function("assert_fails", &[]);
 }
 
 #[test]
@@ -79,16 +79,16 @@ fn boolean() {
 
     vm.constructor("foo", &[]);
 
-    let returns = vm.function("return_true", &[], None);
+    let returns = vm.function("return_true", &[]);
 
     assert_eq!(returns, vec![BorshToken::Bool(true),]);
 
-    let returns = vm.function("return_false", &[], None);
+    let returns = vm.function("return_false", &[]);
 
     assert_eq!(returns, vec![BorshToken::Bool(false),]);
 
-    vm.function("true_arg", &[BorshToken::Bool(true)], None);
-    vm.function("false_arg", &[BorshToken::Bool(false)], None);
+    vm.function("true_arg", &[BorshToken::Bool(true)]);
+    vm.function("false_arg", &[BorshToken::Bool(false)]);
 }
 
 #[test]
@@ -113,7 +113,7 @@ fn address() {
 
     vm.constructor("foo", &[]);
 
-    let returns = vm.function("return_address", &[], None);
+    let returns = vm.function("return_address", &[]);
 
     assert_eq!(
         returns,
@@ -129,7 +129,6 @@ fn address() {
             75, 161, 209, 89, 47, 84, 50, 13, 23, 127, 94, 21, 50, 249, 250, 185, 117, 49, 186,
             134, 82, 130, 112, 97, 218, 24, 157, 198, 40, 105, 118, 27,
         ])],
-        None,
     );
 }
 
@@ -156,7 +155,7 @@ fn test_enum() {
 
     vm.constructor("foo", &[]);
 
-    let returns = vm.function("return_enum", &[], None);
+    let returns = vm.function("return_enum", &[]);
 
     assert_eq!(
         returns,
@@ -172,7 +171,6 @@ fn test_enum() {
             width: 8,
             value: BigInt::from(6u8),
         }],
-        None,
     );
 }
 
@@ -217,7 +215,7 @@ fn bytes() {
 
         vm.constructor("test", &[]);
 
-        let returns = vm.function("return_literal", &[], None);
+        let returns = vm.function("return_literal", &[]);
 
         assert_eq!(
             returns,
@@ -227,7 +225,6 @@ fn bytes() {
         let returns = vm.function(
             "return_arg",
             &[BorshToken::FixedBytes(vec![1, 2, 3, 4, 5, 6, 7])],
-            None,
         );
 
         assert_eq!(
@@ -251,7 +248,6 @@ fn bytes() {
                     BorshToken::FixedBytes(a.to_vec()),
                     BorshToken::FixedBytes(b.to_vec()),
                 ],
-                None,
             );
 
             let res: Vec<u8> = a.iter().zip(b.iter()).map(|(a, b)| a | b).collect();
@@ -271,7 +267,6 @@ fn bytes() {
                     BorshToken::FixedBytes(a.to_vec()),
                     BorshToken::FixedBytes(b.to_vec()),
                 ],
-                None,
             );
 
             let res: Vec<u8> = a.iter().zip(b.iter()).map(|(a, b)| a & b).collect();
@@ -284,7 +279,6 @@ fn bytes() {
                     BorshToken::FixedBytes(a.to_vec()),
                     BorshToken::FixedBytes(b.to_vec()),
                 ],
-                None,
             );
 
             let res: Vec<u8> = a.iter().zip(b.iter()).map(|(a, b)| a ^ b).collect();
@@ -304,7 +298,6 @@ fn bytes() {
                         value: BigInt::from(r),
                     },
                 ],
-                None,
             );
 
             let mut res = (BigUint::from_bytes_be(&a) << r).to_bytes_be();
@@ -328,7 +321,6 @@ fn bytes() {
                         value: BigInt::from(r),
                     },
                 ],
-                None,
             );
 
             let mut res = (BigUint::from_bytes_be(&a) >> r).to_bytes_be();
@@ -423,7 +415,6 @@ fn uint() {
                     width: width as u16,
                     value: a.to_bigint().unwrap(),
                 }],
-                None,
             );
 
             println!("{:x} = {:?} o", a, res);
@@ -440,7 +431,6 @@ fn uint() {
                         value: b.to_bigint().unwrap(),
                     },
                 ],
-                None,
             );
 
             let mut res = a.clone().add(&b);
@@ -468,7 +458,6 @@ fn uint() {
                         value: b.to_bigint().unwrap(),
                     },
                 ],
-                None,
             );
 
             let mut res = a.clone().sub(&b);
@@ -494,7 +483,6 @@ fn uint() {
                         value: b.to_bigint().unwrap(),
                     },
                 ],
-                None,
             );
 
             let mut res = a.clone().mul(&b);
@@ -522,7 +510,6 @@ fn uint() {
                             value: BigInt::from(n),
                         },
                     ],
-                    None,
                 );
 
                 let mut res = a.clone().pow(n);
@@ -550,7 +537,6 @@ fn uint() {
                             value: b.to_bigint().unwrap(),
                         },
                     ],
-                    None,
                 );
 
                 let mut res = a.clone().div(&b);
@@ -577,7 +563,6 @@ fn uint() {
                             value: b.to_bigint().unwrap(),
                         },
                     ],
-                    None,
                 );
 
                 let mut res = a.clone().rem(&b);
@@ -605,7 +590,6 @@ fn uint() {
                         value: b.to_bigint().unwrap(),
                     },
                 ],
-                None,
             );
 
             let mut res = a.clone().bitor(&b);
@@ -631,7 +615,6 @@ fn uint() {
                         value: b.to_bigint().unwrap(),
                     },
                 ],
-                None,
             );
 
             let mut res = a.clone().bitand(&b);
@@ -657,7 +640,6 @@ fn uint() {
                         value: b.to_bigint().unwrap(),
                     },
                 ],
-                None,
             );
 
             let mut res = a.clone().bitxor(&b);
@@ -685,7 +667,6 @@ fn uint() {
                         value: BigInt::from(r),
                     },
                 ],
-                None,
             );
 
             let mut res = a.clone();
@@ -712,7 +693,6 @@ fn uint() {
                         value: BigInt::from(r),
                     },
                 ],
-                None,
             );
 
             let mut res = a.clone();
@@ -770,7 +750,6 @@ fn test_power_overflow_boundaries() {
                     value: BigInt::from(width - 1),
                 },
             ],
-            None,
         );
 
         let res = BigUint::from(2_u32).pow((width - 1) as u32);
@@ -795,7 +774,6 @@ fn test_power_overflow_boundaries() {
                     value: BigInt::from(width + 1),
                 },
             ],
-            None,
         );
 
         assert_ne!(sesa, Ok(0));
@@ -835,7 +813,6 @@ fn test_overflow_boundaries() {
                     value: second_op.clone(),
                 },
             ],
-            None,
         );
         assert_eq!(
             return_value,
@@ -857,7 +834,6 @@ fn test_overflow_boundaries() {
                     value: second_op.clone(),
                 },
             ],
-            None,
         );
         assert_eq!(
             return_value,
@@ -890,7 +866,6 @@ fn test_overflow_boundaries() {
                     value: BigInt::from(2u8),
                 },
             ],
-            None,
         );
 
         assert_ne!(res, Ok(0));
@@ -907,7 +882,6 @@ fn test_overflow_boundaries() {
                     value: BigInt::from(2),
                 },
             ],
-            None,
         );
 
         assert_ne!(res, Ok(0));
@@ -924,7 +898,6 @@ fn test_overflow_boundaries() {
                     value: upper_boundary.clone(),
                 },
             ],
-            None,
         );
 
         assert_ne!(res, Ok(0));
@@ -941,7 +914,6 @@ fn test_overflow_boundaries() {
                     value: lower_boundary.clone(),
                 },
             ],
-            None,
         );
 
         assert_ne!(res, Ok(0));
@@ -958,7 +930,6 @@ fn test_overflow_boundaries() {
                     value: lower_boundary.clone(),
                 },
             ],
-            None,
         );
 
         assert_ne!(res, Ok(0));
@@ -1002,7 +973,6 @@ fn test_mul_within_range_signed() {
                     value: second_op.clone(),
                 },
             ],
-            None,
         );
 
         let res = first_operand_rand.mul(second_op);
@@ -1053,7 +1023,6 @@ fn test_mul_within_range() {
                         value: second_operand_rand.to_bigint().unwrap(),
                     },
                 ],
-                None,
             );
             let res = first_operand_rand * second_operand_rand;
 
@@ -1106,7 +1075,6 @@ fn test_overflow_detect_signed() {
                     value: second_operand_rand.clone(),
                 },
             ],
-            None,
         );
 
         assert_ne!(res, Ok(0));
@@ -1132,7 +1100,6 @@ fn test_overflow_detect_signed() {
                     value: second_operand_rand.clone(),
                 },
             ],
-            None,
         );
 
         assert_ne!(res, Ok(0));
@@ -1178,7 +1145,6 @@ fn test_overflow_detect_unsigned() {
                         value: second_operand_rand.to_bigint().unwrap(),
                     },
                 ],
-                None,
             );
             assert_ne!(res, Ok(0));
         }
@@ -1256,7 +1222,6 @@ fn int() {
                         value: b.clone(),
                     },
                 ],
-                None,
             );
 
             let mut res = a.clone().add(&b);
@@ -1282,7 +1247,6 @@ fn int() {
                         value: b.clone(),
                     },
                 ],
-                None,
             );
 
             let mut res = a.clone().sub(&b);
@@ -1308,7 +1272,6 @@ fn int() {
                         value: b.clone(),
                     },
                 ],
-                None,
             );
 
             let mut res = a.clone().mul(&b);
@@ -1335,7 +1298,6 @@ fn int() {
                             value: b.clone(),
                         },
                     ],
-                    None,
                 );
 
                 let mut res = a.clone().div(&b);
@@ -1361,7 +1323,6 @@ fn int() {
                             value: b.clone(),
                         },
                     ],
-                    None,
                 );
 
                 let mut res = a.clone().rem(&b);
@@ -1388,7 +1349,6 @@ fn int() {
                         value: b.clone(),
                     },
                 ],
-                None,
             );
 
             let mut res = a.clone().bitor(&b);
@@ -1414,7 +1374,6 @@ fn int() {
                         value: b.clone(),
                     },
                 ],
-                None,
             );
 
             let mut res = a.clone().bitand(&b);
@@ -1440,7 +1399,6 @@ fn int() {
                         value: b.clone(),
                     },
                 ],
-                None,
             );
 
             let mut res = a.clone().bitxor(&b);
@@ -1468,7 +1426,6 @@ fn int() {
                         value: BigInt::from(r),
                     },
                 ],
-                None,
             );
 
             let mut res = a.clone().shl(r);
@@ -1495,7 +1452,6 @@ fn int() {
                         value: BigInt::from(r),
                     },
                 ],
-                None,
             );
 
             let mut res = a.shr(r);
@@ -1541,15 +1497,11 @@ fn bytes_cast() {
 
     vm.constructor("foo", &[]);
 
-    let returns = vm.function(
-        "to_bytes",
-        &[BorshToken::FixedBytes(b"abcd".to_vec())],
-        None,
-    );
+    let returns = vm.function("to_bytes", &[BorshToken::FixedBytes(b"abcd".to_vec())]);
 
     assert_eq!(returns, vec![BorshToken::Bytes(b"abcd".to_vec())]);
 
-    let returns = vm.function("to_bytes5", &[BorshToken::Bytes(b"abcde".to_vec())], None);
+    let returns = vm.function("to_bytes5", &[BorshToken::Bytes(b"abcde".to_vec())]);
 
     assert_eq!(returns, vec![BorshToken::FixedBytes(b"abcde".to_vec())]);
 }

tests/solana_tests/rational.rs

@@ -23,7 +23,7 @@ fn rational() {
 
     vm.constructor("foo", &[]);
 
-    let returns = vm.function("test", &[], None);
+    let returns = vm.function("test", &[]);
 
     assert_eq!(
         returns,
@@ -33,7 +33,7 @@ fn rational() {
         }]
     );
 
-    let returns = vm.function("test2", &[], None);
+    let returns = vm.function("test2", &[]);
 
     assert_eq!(
         returns,
@@ -55,7 +55,7 @@ fn rational() {
 
     vm.constructor("foo", &[]);
 
-    let returns = vm.function("test", &[], None);
+    let returns = vm.function("test", &[]);
 
     assert_eq!(
         returns,
@@ -77,7 +77,7 @@ fn rational() {
 
     vm.constructor("foo", &[]);
 
-    let returns = vm.function("test", &[], None);
+    let returns = vm.function("test", &[]);
 
     assert_eq!(
         returns,
@@ -99,7 +99,7 @@ fn rational() {
 
     vm.constructor("foo", &[]);
 
-    let returns = vm.function("test", &[], None);
+    let returns = vm.function("test", &[]);
 
     assert_eq!(
         returns,
@@ -121,7 +121,7 @@ fn rational() {
 
     vm.constructor("foo", &[]);
 
-    let returns = vm.function("test", &[], None);
+    let returns = vm.function("test", &[]);
 
     assert_eq!(
         returns,
@@ -142,7 +142,7 @@ fn rational() {
 
     vm.constructor("foo", &[]);
 
-    let returns = vm.function("test", &[], None);
+    let returns = vm.function("test", &[]);
 
     assert_eq!(
         returns,
@@ -163,7 +163,7 @@ fn rational() {
 
     vm.constructor("foo", &[]);
 
-    let returns = vm.function("test", &[], None);
+    let returns = vm.function("test", &[]);
 
     assert_eq!(
         returns,
@@ -190,7 +190,6 @@ fn rational() {
             width: 64,
             value: BigInt::from(982451653u32),
         }],
-        None,
     );
 
     assert_eq!(

tests/solana_tests/returns.rs

@@ -33,7 +33,7 @@ fn return_single() {
     );
     vm.constructor("foo", &[]);
 
-    let returns = vm.function("f", &[], None);
+    let returns = vm.function("f", &[]);
     assert_eq!(
         returns,
         vec![BorshToken::Uint {
@@ -42,7 +42,7 @@ fn return_single() {
         },]
     );
 
-    let returns = vm.function("g", &[], None);
+    let returns = vm.function("g", &[]);
     assert_eq!(
         returns,
         vec![BorshToken::Uint {
@@ -51,7 +51,7 @@ fn return_single() {
         },]
     );
 
-    let returns = vm.function("h", &[], None);
+    let returns = vm.function("h", &[]);
     assert_eq!(
         returns,
         vec![BorshToken::Uint {
@@ -60,7 +60,7 @@ fn return_single() {
         },]
     );
 
-    let returns = vm.function("i", &[], None);
+    let returns = vm.function("i", &[]);
     assert_eq!(
         returns,
         vec![BorshToken::Uint {
@@ -69,7 +69,7 @@ fn return_single() {
         },]
     );
 
-    let returns = vm.function("j", &[], None);
+    let returns = vm.function("j", &[]);
     assert_eq!(
         returns,
         vec![BorshToken::Uint {
@@ -91,7 +91,7 @@ fn return_ternary() {
     );
 
     vm.constructor("foo", &[]);
-    let returns = vm.function("f", &[], None);
+    let returns = vm.function("f", &[]);
 
     assert_eq!(
         returns,
@@ -117,7 +117,7 @@ fn return_ternary() {
     );
 
     vm.constructor("foo", &[]);
-    let returns = vm.function("f", &[], None);
+    let returns = vm.function("f", &[]);
 
     assert_eq!(
         returns,
@@ -157,9 +157,9 @@ fn return_nothing() {
     );
 
     vm.constructor("foo", &[]);
-    let _returns = vm.function("strange", &[], None);
-    let _returns = vm.function("inc", &[], None);
-    let returns = vm.function("get", &[], None);
+    let _returns = vm.function("strange", &[]);
+    let _returns = vm.function("inc", &[]);
+    let returns = vm.function("get", &[]);
 
     assert_eq!(
         returns,
@@ -193,8 +193,8 @@ fn return_nothing() {
     );
 
     vm.constructor("foo", &[]);
-    let _returns = vm.function("f", &[], None);
-    let returns = vm.function("get", &[], None);
+    let _returns = vm.function("f", &[]);
+    let returns = vm.function("get", &[]);
 
     assert_eq!(
         returns,
@@ -221,7 +221,7 @@ fn return_function() {
     );
 
     vm.constructor("foo", &[]);
-    let returns = vm.function("f", &[], None);
+    let returns = vm.function("f", &[]);
 
     assert_eq!(
         returns,
@@ -251,7 +251,7 @@ fn return_function() {
     );
 
     vm.constructor("foo", &[]);
-    let returns = vm.function("f", &[], None);
+    let returns = vm.function("f", &[]);
 
     assert_eq!(
         returns,

tests/solana_tests/signature_verify.rs

@@ -66,7 +66,6 @@ fn verify() {
             BorshToken::Bytes(message.to_vec()),
             BorshToken::Bytes(signature_bs.clone()),
         ],
-        None,
     );
 
     assert_eq!(returns, vec![BorshToken::Bool(false)]);
@@ -96,7 +95,6 @@ fn verify() {
             BorshToken::Bytes(message.to_vec()),
             BorshToken::Bytes(signature_bs.clone()),
         ],
-        None,
     );
 
     assert_eq!(returns, vec![BorshToken::Bool(true)]);
@@ -125,7 +123,6 @@ fn verify() {
             BorshToken::Bytes(message.to_vec()),
             BorshToken::Bytes(signature_bs),
         ],
-        None,
     );
 
     assert_eq!(returns, vec![BorshToken::Bool(false)]);

tests/solana_tests/simple.rs

@@ -26,7 +26,7 @@ fn simple() {
 
     vm.logs.truncate(0);
 
-    vm.function("test", &[], None);
+    vm.function("test", &[]);
 
     assert_eq!(vm.logs, "Hello from function");
 }
@@ -83,7 +83,6 @@ fn parameters() {
                 value: BigInt::from(10u8),
             },
         ],
-        None,
     );
 
     assert_eq!(vm.logs, "x is 10");
@@ -102,7 +101,6 @@ fn parameters() {
                 value: BigInt::from(102u8),
             },
         ],
-        None,
     );
 
     assert_eq!(vm.logs, "y is 102");
@@ -127,7 +125,6 @@ fn returns() {
             width: 32,
             value: BigInt::from(10u8),
         }],
-        None,
     );
 
     assert_eq!(
@@ -155,7 +152,6 @@ fn returns() {
             width: 64,
             value: BigInt::from(982451653u64),
         }],
-        None,
     );
 
     assert_eq!(
@@ -203,18 +199,18 @@ fn flipper() {
         hex::decode("6fc90ec500000000000000001800000001").unwrap()
     );
 
-    let returns = vm.function("get", &[], None);
+    let returns = vm.function("get", &[]);
 
     assert_eq!(returns, vec![BorshToken::Bool(true)]);
 
-    vm.function("flip", &[], None);
+    vm.function("flip", &[]);
 
     assert_eq!(
         vm.data()[0..17].to_vec(),
         hex::decode("6fc90ec500000000000000001800000000").unwrap()
     );
 
-    let returns = vm.function("get", &[], None);
+    let returns = vm.function("get", &[]);
 
     assert_eq!(returns, vec![BorshToken::Bool(false)]);
 }
@@ -258,7 +254,7 @@ fn incrementer() {
         }],
     );
 
-    let returns = vm.function("get", &[], None);
+    let returns = vm.function("get", &[]);
 
     assert_eq!(
         returns,
@@ -274,10 +270,9 @@ fn incrementer() {
             width: 32,
             value: BigInt::from(5u8),
         }],
-        None,
     );
 
-    let returns = vm.function("get", &[], None);
+    let returns = vm.function("get", &[]);
 
     assert_eq!(
         returns,
@@ -359,7 +354,7 @@ fn dead_storage_bug() {
 
     vm.constructor("deadstorage", &[]);
 
-    let returns = vm.function("v", &[], None);
+    let returns = vm.function("v", &[]);
 
     assert_eq!(
         returns,
@@ -427,7 +422,6 @@ contract test3 {
                 width: 32,
                 value: BigInt::from(i),
             }],
-            None,
         );
 
         assert_eq!(
@@ -451,7 +445,6 @@ contract test3 {
                 },
                 BorshToken::Bool(true),
             ],
-            None,
         );
 
         assert_eq!(
@@ -479,7 +472,6 @@ contract test3 {
                 },
                 BorshToken::Bool(false),
             ],
-            None,
         );
 
         assert_eq!(
@@ -508,7 +500,6 @@ contract test3 {
                 width: 32,
                 value: BigInt::from(i),
             }],
-            None,
         );
 
         assert_eq!(

tests/solana_tests/storage.rs

@@ -19,7 +19,7 @@ fn simple() {
     );
 
     vm.constructor("foo", &[]);
-    let returns = vm.function("boom", &[], None);
+    let returns = vm.function("boom", &[]);
     assert_eq!(
         returns,
         vec![BorshToken::Int {
@@ -49,7 +49,7 @@ fn simple() {
     );
 
     vm.constructor("c", &[]);
-    let returns = vm.function("func", &[], None);
+    let returns = vm.function("func", &[]);
     assert_eq!(
         returns,
         vec![BorshToken::Int {
@@ -83,15 +83,11 @@ fn string() {
         vec![65, 177, 160, 100, 0, 0, 0, 0, 0, 0, 0, 0, 24, 0, 0, 0, 0, 0, 0, 0]
     );
 
-    let returns = vm.function("get", &[], None);
+    let returns = vm.function("get", &[]);
 
     assert_eq!(returns, vec![BorshToken::String(String::from(""))]);
 
-    vm.function(
-        "set",
-        &[BorshToken::String(String::from("Hello, World!"))],
-        None,
-    );
+    vm.function("set", &[BorshToken::String(String::from("Hello, World!"))]);
 
     assert_eq!(
         vm.data()[0..20].to_vec(),
@@ -100,7 +96,7 @@ fn string() {
 
     assert_eq!(vm.data()[40..53].to_vec(), b"Hello, World!");
 
-    let returns = vm.function("get", &[], None);
+    let returns = vm.function("get", &[]);
 
     assert_eq!(
         returns,
@@ -109,13 +105,9 @@ fn string() {
 
     // try replacing it with a string of the same length. This is a special
     // fast-path handling
-    vm.function(
-        "set",
-        &[BorshToken::String(String::from("Hallo, Werld!"))],
-        None,
-    );
+    vm.function("set", &[BorshToken::String(String::from("Hallo, Werld!"))]);
 
-    let returns = vm.function("get", &[], None);
+    let returns = vm.function("get", &[]);
 
     assert_eq!(
         returns,
@@ -129,9 +121,9 @@ fn string() {
 
     // Try setting this to an empty string. This is also a special case where
     // the result should be offset 0
-    vm.function("set", &[BorshToken::String(String::from(""))], None);
+    vm.function("set", &[BorshToken::String(String::from(""))]);
 
-    let returns = vm.function("get", &[], None);
+    let returns = vm.function("get", &[]);
 
     assert_eq!(returns, vec![BorshToken::String(String::from(""))]);
 
@@ -173,7 +165,7 @@ fn bytes() {
         vec![11, 66, 182, 57, 0, 0, 0, 0, 0, 0, 0, 0, 24, 0, 0, 0, 0, 0, 0, 0]
     );
 
-    let returns = vm.function("foo_length", &[], None);
+    let returns = vm.function("foo_length", &[]);
 
     assert_eq!(
         returns,
@@ -188,7 +180,6 @@ fn bytes() {
         &[BorshToken::Bytes(
             b"The shoemaker always wears the worst shoes".to_vec(),
         )],
-        None,
     );
 
     assert_eq!(
@@ -206,7 +197,6 @@ fn bytes() {
                 width: 32,
                 value: BigInt::from(i),
             }],
-            None,
         );
 
         assert_eq!(returns, vec![BorshToken::FixedBytes(vec![*b])]);
@@ -221,7 +211,6 @@ fn bytes() {
             },
             BorshToken::FixedBytes(b"E".to_vec()),
         ],
-        None,
     );
 
     vm.function(
@@ -233,7 +222,6 @@ fn bytes() {
             },
             BorshToken::FixedBytes(b"E".to_vec()),
         ],
-        None,
     );
 
     for (i, b) in b"ThE shoEmaker always wears the worst shoes"
@@ -246,7 +234,6 @@ fn bytes() {
                 width: 32,
                 value: BigInt::from(i),
             }],
-            None,
         );
 
         assert_eq!(returns, vec![BorshToken::FixedBytes(vec![*b])]);
@@ -290,7 +277,6 @@ fn bytes_set_subscript_range() {
             },
             BorshToken::FixedBytes(b"E".to_vec()),
         ],
-        None,
     );
 }
 
@@ -327,7 +313,6 @@ fn bytes_get_subscript_range() {
         &[BorshToken::Bytes(
             b"The shoemaker always wears the worst shoes".to_vec(),
         )],
-        None,
     );
 
     vm.function(
@@ -336,7 +321,6 @@ fn bytes_get_subscript_range() {
             width: 32,
             value: BigInt::from(0x80000000u64),
         }],
-        None,
     );
 }
 
@@ -387,29 +371,29 @@ fn bytes_push_pop() {
 
     vm.constructor("c", &[]);
 
-    let returns = vm.function("get_bs", &[], None);
+    let returns = vm.function("get_bs", &[]);
 
     assert_eq!(returns, vec![BorshToken::Bytes(vec!(0x0e, 0xda))]);
 
-    let returns = vm.function("pop", &[], None);
+    let returns = vm.function("pop", &[]);
 
     assert_eq!(returns, vec![BorshToken::FixedBytes(vec!(0xda))]);
 
-    let returns = vm.function("get_bs", &[], None);
+    let returns = vm.function("get_bs", &[]);
 
     assert_eq!(returns, vec![BorshToken::Bytes(vec!(0x0e))]);
 
-    vm.function("push", &[BorshToken::FixedBytes(vec![0x41])], None);
+    vm.function("push", &[BorshToken::FixedBytes(vec![0x41])]);
 
     println!("data:{}", hex::encode(vm.data()));
 
-    let returns = vm.function("get_bs", &[], None);
+    let returns = vm.function("get_bs", &[]);
 
     assert_eq!(returns, vec![BorshToken::Bytes(vec!(0x0e, 0x41))]);
 
-    vm.function("push", &[BorshToken::FixedBytes(vec![0x01])], None);
+    vm.function("push", &[BorshToken::FixedBytes(vec![0x01])]);
 
-    let returns = vm.function("get_bs", &[], None);
+    let returns = vm.function("get_bs", &[]);
 
     assert_eq!(returns, vec![BorshToken::Bytes(vec!(0x0e, 0x41, 0x01))]);
 }
@@ -430,7 +414,7 @@ fn bytes_empty_pop() {
 
     vm.constructor("c", &[]);
 
-    vm.function("pop", &[], None);
+    vm.function("pop", &[]);
 }
 
 #[test]
@@ -462,7 +446,7 @@ fn simple_struct() {
 
     vm.constructor("c", &[]);
 
-    vm.function("set_s2", &[], None);
+    vm.function("set_s2", &[]);
 
     assert_eq!(
         vm.data()[0..32].to_vec(),
@@ -472,7 +456,7 @@ fn simple_struct() {
         ]
     );
 
-    let returns = vm.function("get_s1", &[], None);
+    let returns = vm.function("get_s1", &[]);
 
     assert_eq!(
         returns,
@@ -500,10 +484,9 @@ fn simple_struct() {
                 value: BigInt::from(3240121u32),
             },
         ])],
-        None,
     );
 
-    let returns = vm.function("get_s1", &[], None);
+    let returns = vm.function("get_s1", &[]);
 
     assert_eq!(
         returns,
@@ -555,7 +538,7 @@ fn struct_in_struct() {
 
     vm.constructor("c", &[]);
 
-    vm.function("set_s2", &[], None);
+    vm.function("set_s2", &[]);
 
     assert_eq!(
         vm.data()[0..52].to_vec(),
@@ -566,7 +549,7 @@ fn struct_in_struct() {
         ]
     );
 
-    let returns = vm.function("get_s1", &[], None);
+    let returns = vm.function("get_s1", &[]);
 
     assert_eq!(
         returns,
@@ -608,10 +591,9 @@ fn struct_in_struct() {
                 value: BigInt::from(12345678901234567890u64),
             },
         ])],
-        None,
     );
 
-    let returns = vm.function("get_s1", &[], None);
+    let returns = vm.function("get_s1", &[]);
 
     assert_eq!(
         returns,
@@ -665,7 +647,7 @@ fn string_in_struct() {
 
     vm.constructor("c", &[]);
 
-    vm.function("set_s2", &[], None);
+    vm.function("set_s2", &[]);
 
     assert_eq!(
         vm.data()[0..64].to_vec(),
@@ -676,7 +658,7 @@ fn string_in_struct() {
         ]
     );
 
-    let returns = vm.function("get_s1", &[], None);
+    let returns = vm.function("get_s1", &[]);
 
     assert_eq!(
         returns,
@@ -706,10 +688,9 @@ fn string_in_struct() {
                 value: BigInt::from(12345678901234567890u64),
             },
         ])],
-        None,
     );
 
-    let returns = vm.function("get_s1", &[], None);
+    let returns = vm.function("get_s1", &[]);
 
     assert_eq!(
         returns,
@@ -781,9 +762,9 @@ fn complex_struct() {
 
     vm.constructor("c", &[]);
 
-    vm.function("set_s2", &[], None);
+    vm.function("set_s2", &[]);
 
-    let returns = vm.function("get_s1", &[], None);
+    let returns = vm.function("get_s1", &[]);
 
     assert_eq!(
         returns,
@@ -845,10 +826,9 @@ fn complex_struct() {
             ]),
             BorshToken::String(String::from("yadayada")),
         ],
-        None,
     );
 
-    let returns = vm.function("get_s1", &[], None);
+    let returns = vm.function("get_s1", &[]);
 
     assert_eq!(
         returns,
@@ -880,9 +860,9 @@ fn complex_struct() {
         ]
     );
 
-    vm.function("rm", &[], None);
+    vm.function("rm", &[]);
 
-    let returns = vm.function("get_s1", &[], None);
+    let returns = vm.function("get_s1", &[]);
 
     assert_eq!(
         returns,

tests/solana_tests/strings.rs

@@ -25,9 +25,8 @@ fn storage_string_length() {
     let _ = vm.function(
         "setString",
         &[BorshToken::String("coffee_tastes_good".to_string())],
-        None,
     );
-    let returns = vm.function("getLength", &[], None);
+    let returns = vm.function("getLength", &[]);
 
     assert_eq!(
         returns[0],
@@ -61,7 +60,7 @@ fn load_string_vector() {
     );
 
     vm.constructor("Testing", &[]);
-    let returns = vm.function("testLength", &[], None);
+    let returns = vm.function("testLength", &[]);
     assert_eq!(
         returns[0],
         BorshToken::Uint {
@@ -90,7 +89,6 @@ fn load_string_vector() {
             width: 32,
             value: BigInt::zero(),
         }],
-        None,
     );
     assert_eq!(returns[0], BorshToken::String("tea".to_string()));
 
@@ -100,7 +98,6 @@ fn load_string_vector() {
             width: 32,
             value: BigInt::one(),
         }],
-        None,
     );
     assert_eq!(returns[0], BorshToken::String("coffe".to_string()));
 
@@ -110,7 +107,6 @@ fn load_string_vector() {
             width: 32,
             value: BigInt::from(2u8),
         }],
-        None,
     );
     assert_eq!(returns[0], BorshToken::String("sixsix".to_string()));
 }

tests/solana_tests/unused_variable_elimination.rs

@@ -38,8 +38,8 @@ fn test_returns() {
 
     let mut vm = build_solidity(file);
     vm.constructor("c1", &[]);
-    let _ = vm.function("assign", &[], None);
-    let returns = vm.function("pb1", &[], None);
+    let _ = vm.function("assign", &[]);
+    let returns = vm.function("pb1", &[]);
 
     assert_eq!(
         returns,
@@ -49,7 +49,7 @@ fn test_returns() {
         }]
     );
 
-    let returns = vm.function("test1", &[], None);
+    let returns = vm.function("test1", &[]);
     assert_eq!(
         returns,
         vec![BorshToken::Int {
@@ -57,7 +57,7 @@ fn test_returns() {
             value: BigInt::from(52u8)
         }]
     );
-    let returns = vm.function("test2", &[], None);
+    let returns = vm.function("test2", &[]);
     assert_eq!(
         returns,
         vec![BorshToken::Int {

tests/solana_tests/using.rs

@@ -30,7 +30,7 @@ fn using_for_contracts() {
     );
 
     runtime.constructor("C", &[]);
-    runtime.function("test", &[], None);
+    runtime.function("test", &[]);
 
     assert_eq!(runtime.logs, "Hello");
 
@@ -73,7 +73,7 @@ fn using_for_contracts() {
     );
 
     runtime.constructor("foo", &[]);
-    runtime.function("test", &[], None);
+    runtime.function("test", &[]);
 
     assert_eq!(runtime.logs, "X libX contractx:2");
 }

tests/solana_tests/vector_to_slice.rs

@@ -21,7 +21,7 @@ fn test_slice_in_phi() {
 
     let mut vm = build_solidity(file);
     vm.constructor("c1", &[]);
-    let returns = vm.function("test", &[], None);
+    let returns = vm.function("test", &[]);
 
     assert_eq!(returns, vec![BorshToken::String(String::from("Hello!"))]);
 }

tests/solana_tests/yul.rs

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::{account_new, build_solidity, BorshToken};
+use crate::{build_solidity, BorshToken};
 use num_bigint::{BigInt, Sign};
 use num_traits::{One, Zero};
 
@@ -62,7 +62,7 @@ contract testing  {
 
     vm.constructor("testing", &[]);
 
-    let returns = vm.function("test_slot", &[], None);
+    let returns = vm.function("test_slot", &[]);
     assert_eq!(
         returns,
         vec![BorshToken::Uint {
@@ -91,7 +91,6 @@ contract testing  {
                 value: BigInt::from(11u8),
             },
         ])],
-        None,
     );
 
     assert_eq!(
@@ -109,7 +108,7 @@ contract testing  {
         ]
     );
 
-    let returns = vm.function("selector_address", &[], None);
+    let returns = vm.function("selector_address", &[]);
     assert_eq!(
         returns,
         vec![
@@ -173,7 +172,6 @@ contract testing  {
             width: 64,
             value: BigInt::from(5u8),
         }],
-        None,
     );
     assert_eq!(
         returns,
@@ -195,7 +193,6 @@ contract testing  {
             width: 64,
             value: BigInt::from(78u8),
         }],
-        None,
     );
     assert_eq!(
         returns,
@@ -217,7 +214,6 @@ contract testing  {
             width: 64,
             value: BigInt::from(259u16),
         }],
-        None,
     );
     assert_eq!(
         returns,
@@ -276,7 +272,6 @@ contract c {
             width: 256,
             value: BigInt::from_bytes_be(Sign::Plus, &num),
         }],
-        None,
     );
     assert_eq!(
         returns,
@@ -298,7 +293,6 @@ contract c {
                 value: BigInt::from(3u8),
             },
         ],
-        None,
     );
     assert_eq!(
         returns,
@@ -326,7 +320,6 @@ contract c {
                 value: BigInt::zero(),
             },
         ],
-        None,
     );
     assert_eq!(
         returns,
@@ -358,7 +351,6 @@ contract c {
                 value: BigInt::from(3u8),
             },
         ],
-        None,
     );
     assert_eq!(
         returns,
@@ -390,7 +382,6 @@ contract c {
                 value: BigInt::zero(),
             },
         ],
-        None,
     );
     assert_eq!(
         returns,
@@ -443,7 +434,6 @@ fn external_function() {
             },
             BorshToken::FixedBytes(vec![1, 2, 3, 4, 5, 6, 7, 8]),
         ],
-        None,
     );
 
     let selector = returns[0].clone().into_fixed_bytes().unwrap();
@@ -477,18 +467,11 @@ contract testing  {
             ret := a
         }
     }
-
-    function test_caller() public view returns (uint256 ret) {
-        assembly {
-            let a := caller()
-            ret := a
-        }
-    }
 }"#,
     );
 
     runtime.constructor("testing", &[]);
-    let returns = runtime.function("test_address", &[], None);
+    let returns = runtime.function("test_address", &[]);
     let addr = returns[0].clone().into_bigint().unwrap();
     let b_vec = addr.to_bytes_be().1;
     assert_eq!(&b_vec, runtime.stack[0].data.as_ref());
@@ -498,7 +481,7 @@ contract testing  {
         .get_mut(&runtime.stack[0].data)
         .unwrap()
         .lamports = 102;
-    let returns = runtime.function("test_balance", &[], None);
+    let returns = runtime.function("test_balance", &[]);
     assert_eq!(
         returns,
         vec![BorshToken::Uint {
@@ -507,7 +490,7 @@ contract testing  {
         },]
     );
 
-    let returns = runtime.function("test_selfbalance", &[], None);
+    let returns = runtime.function("test_selfbalance", &[]);
     assert_eq!(
         returns,
         vec![BorshToken::Uint {
@@ -515,13 +498,6 @@ contract testing  {
             value: BigInt::from(102u8),
         },]
     );
-
-    let sender = account_new();
-
-    let returns = runtime.function("test_caller", &[], Some(&sender));
-    let addr = returns[0].clone().into_bigint().unwrap();
-    let b_vec = addr.to_bytes_be().1;
-    assert_eq!(b_vec, sender.to_vec());
 }
 
 #[test]
@@ -546,7 +522,7 @@ fn addmod_mulmod() {
 
     vm.constructor("foo", &[]);
 
-    let returns = vm.function("testMod", &[], None);
+    let returns = vm.function("testMod", &[]);
     assert_eq!(
         returns,
         vec![
@@ -630,7 +606,6 @@ contract Testing {
             width: 256,
             value: BigInt::one(),
         }],
-        None,
     );
     assert_eq!(
         returns[0],
@@ -646,7 +621,6 @@ contract Testing {
             width: 256,
             value: BigInt::from(2u8),
         }],
-        None,
     );
     assert_eq!(
         returns[0],
@@ -662,7 +636,6 @@ contract Testing {
             width: 256,
             value: BigInt::from(6u8),
         }],
-        None,
     );
     assert_eq!(
         returns[0],
@@ -678,7 +651,6 @@ contract Testing {
             width: 256,
             value: BigInt::one(),
         }],
-        None,
     );
     assert_eq!(
         returns[0],
@@ -694,7 +666,6 @@ contract Testing {
             width: 256,
             value: BigInt::from(2u8),
         }],
-        None,
     );
     assert_eq!(
         returns[0],
@@ -710,7 +681,6 @@ contract Testing {
             width: 256,
             value: BigInt::from(6u8),
         }],
-        None,
     );
     assert_eq!(
         returns[0],
@@ -726,7 +696,6 @@ contract Testing {
             width: 256,
             value: BigInt::from(3u8),
         }],
-        None,
     );
     assert_eq!(
         returns[0],