Substrate: Implement call flags (#1376)

docs/examples/substrate/call_flags.sol

@@ -0,0 +1,16 @@
+library CallFlags {
+    uint32 constant FORWARD_INPUT = 1;
+    uint32 constant CLONE_INPUT = 2;
+    uint32 constant TAIL_CALL = 4;
+    uint32 constant ALLOW_REENTRY = 8;
+}
+
+contract Reentrant {
+    function reentrant_tail_call(
+        address _address,
+        bytes4 selector
+    ) public returns (bytes ret) {
+        (bool ok, ret) = _address.call{flags: CallFlags.ALLOW_REENTRY}(selector);
+        require(ok);
+    }
+}

docs/targets/substrate.rst

@@ -49,3 +49,19 @@ import object.
 
     The import file ``substrate`` is only available when compiling for the Substrate
     target.
+
+Call Flags
+__________
+
+The Substrate contracts pallet knows several 
+`flags <https://github.com/paritytech/substrate/blob/6e0059a416a5768e58765a49b33c21920c0b0eb9/frame/contracts/src/wasm/runtime.rs#L392>`_ 
+that can be used when calling other contracts.
+
+Solang allows a ``flags`` call argument of type ``uint32`` in the ``address.call()`` function to set desired flags.
+By default (if this argument is unset), no flag will be set.
+
+The following example shows how call flags can be used:
+
+.. include:: ../examples/substrate/call_flags.sol
+  :code: solidity
+

integration/substrate/call_flags.sol

@@ -0,0 +1,63 @@
+contract CallFlags {
+    uint8 roundtrips;
+
+    // See https://github.com/paritytech/substrate/blob/5ea6d95309aaccfa399c5f72e5a14a4b7c6c4ca1/frame/contracts/src/wasm/runtime.rs#L373
+    enum CallFlag { FORWARD_INPUT, CLONE_INPUT, TAIL_CALL, ALLOW_REENTRY }
+    function bitflags(CallFlag[] _flags) internal pure returns (uint32 flags) {
+        for (uint n = 0; n < _flags.length; n++) {
+            flags |= (2 ** uint32(_flags[n]));
+        }
+    }
+
+    // Reentrancy is required for reaching the `foo` function for itself.
+    //
+    // Cloning and forwarding should have the effect of calling this function again, regardless of what _address was passed.
+    // Furthermore:
+    // Cloning the input should work together with reentrancy.
+    // Forwarding the input should fail due to reading the input more than once in the loop
+    // Tail call should work with any combination of input forwarding.
+    function echo(
+        address _address,
+        bytes4 _selector,
+        uint32 _x,
+        CallFlag[] _flags
+    ) public payable returns(uint32 ret) {
+        for (uint n = 0; n < 2; n++) {
+            if (roundtrips > 1) {
+                return _x;
+            }
+            roundtrips += 1;
+
+            bytes input = abi.encode(_selector, _x);
+            (bool ok, bytes raw) =  _address.call{flags: bitflags(_flags)}(input);
+            require(ok);
+            ret = abi.decode(raw, (uint32));
+
+            roundtrips -= 1;
+        }
+    }
+
+    @selector([0,0,0,0])
+    function foo(uint32 x) public pure returns(uint32) {
+        return x;
+    }
+
+    // Yields different result for tail calls
+    function tail_call_it(
+        address _address,
+        bytes4 _selector,
+        uint32 _x,
+        CallFlag[] _flags
+    ) public returns(uint32 ret) {
+        bytes input = abi.encode(_selector, _x);
+        (bool ok, bytes raw) =  _address.call{flags: bitflags(_flags)}(input);
+        require(ok);
+        ret = abi.decode(raw, (uint32));
+        ret += 1;
+    }
+
+    // Does this.call() on this instead of address.call()
+    function call_this(uint32 _x) public pure returns (uint32) {
+        return this.foo{flags: bitflags([CallFlag.ALLOW_REENTRY])}(_x);
+    }
+}

integration/substrate/call_flags.spec.ts

@@ -0,0 +1,85 @@
+import expect from 'expect';
+import { createConnection, deploy, aliceKeypair, query, debug_buffer, } from './index';
+import { ContractPromise } from '@polkadot/api-contract';
+import { ApiPromise } from '@polkadot/api';
+import { KeyringPair } from '@polkadot/keyring/types';
+
+enum CallFlags {
+    FORWARD_INPUT, CLONE_INPUT, TAIL_CALL, ALLOW_REENTRY
+}
+
+describe('Deploy the CallFlags contract and tests for various call flag combinations', () => {
+    let conn: ApiPromise;
+    let contract: ContractPromise;
+    let alice: KeyringPair;
+    const voyager = 987654321;
+    const foo = [0, 0, 0, 0];
+
+    before(async function () {
+        alice = aliceKeypair();
+        conn = await createConnection();
+        const deployment = await deploy(conn, alice, 'CallFlags.contract', 0n);
+        contract = new ContractPromise(conn, deployment.abi, deployment.address);
+    });
+
+    after(async function () {
+        await conn.disconnect();
+    });
+
+    it('works with the reentry flag', async function () {
+        const flags = [CallFlags.ALLOW_REENTRY];
+        const answer = await query(conn, alice, contract, "echo", [contract.address, foo, voyager, flags]);
+        expect(answer.output?.toJSON()).toStrictEqual(voyager);
+    });
+
+    it('works with the reentry and tail call flags', async function () {
+        const flags = [CallFlags.ALLOW_REENTRY, CallFlags.TAIL_CALL];
+        const answer = await query(conn, alice, contract, "echo", [contract.address, foo, voyager, flags]);
+        expect(answer.output?.toJSON()).toStrictEqual(voyager);
+    });
+
+    it('works with the reentry and clone input flags', async function () {
+        const flags = [CallFlags.ALLOW_REENTRY, CallFlags.CLONE_INPUT];
+        const answer = await query(conn, alice, contract, "echo", [contract.address, foo, voyager, flags]);
+        expect(answer.output?.toJSON()).toStrictEqual(voyager);
+    });
+
+    it('works with the reentry, tail call and clone input flags', async function () {
+        const flags = [CallFlags.ALLOW_REENTRY, CallFlags.TAIL_CALL, CallFlags.CLONE_INPUT];
+        const answer = await query(conn, alice, contract, "echo", [contract.address, foo, voyager, flags]);
+        expect(answer.output?.toJSON()).toStrictEqual(voyager);
+    });
+
+    it('fails without the reentry flag', async function () {
+        const flags = [CallFlags.TAIL_CALL];
+        const answer = await query(conn, alice, contract, "echo", [contract.address, foo, voyager, flags]);
+        const { index, error } = answer.result.asErr.asModule;
+        // Module 8 error 0x14 is ReentranceDenied in the contracts pallet
+        expect(index.toJSON()).toStrictEqual(8);
+        expect(error.toJSON()).toStrictEqual("0x14000000");
+    });
+
+    it('fails with the input forwarding flag', async function () {
+        const flags = [CallFlags.ALLOW_REENTRY, CallFlags.FORWARD_INPUT];
+        const answer = await query(conn, alice, contract, "echo", [contract.address, foo, voyager, flags]);
+        const { index, error } = answer.result.asErr.asModule;
+        // Module 8 error 0x0b is ContractTrapped in the contracts pallet
+        expect(index.toJSON()).toStrictEqual(8);
+        expect(error.toJSON()).toStrictEqual("0x0b000000");
+    });
+
+    it('test for the tail call flag to work correctly', async function () {
+        let flags = [CallFlags.ALLOW_REENTRY];
+        let answer = await query(conn, alice, contract, "tail_call_it", [contract.address, foo, voyager, flags]);
+        expect(answer.output?.toJSON()).toStrictEqual(voyager + 1);
+
+        flags = [CallFlags.ALLOW_REENTRY, CallFlags.TAIL_CALL];
+        answer = await query(conn, alice, contract, "tail_call_it", [contract.address, foo, voyager, flags]);
+        expect(answer.output?.toJSON()).toStrictEqual(voyager);
+    });
+
+    it('works on calls on "this"', async function () {
+        const answer = await query(conn, alice, contract, "call_this", [voyager]);
+        expect(answer.output?.toJSON()).toStrictEqual(voyager);
+    });
+});

src/codegen/cfg.rs

@@ -141,6 +141,7 @@ pub enum Instr {
         gas: Expression,
         callty: CallTy,
         contract_function_no: Option<(usize, usize)>,
+        flags: Option<Expression>,
     },
     /// Value transfer; either address.send() or address.transfer()
     ValueTransfer {
@@ -1170,10 +1171,11 @@ impl ControlFlowGraph {
                 seeds,
                 gas,
                 callty,
-                contract_function_no
+                contract_function_no,
+                flags
             } => {
                 format!(
-                    "{} = external call::{} address:{} payload:{} value:{} gas:{} accounts:{} seeds:{} contract|function:{}",
+                    "{} = external call::{} address:{} payload:{} value:{} gas:{} accounts:{} seeds:{} contract|function:{} flags:{}",
                     match success {
                         Some(i) => format!("%{}", self.vars[i].id.name),
                         None => "_".to_string(),
@@ -1201,7 +1203,8 @@ impl ControlFlowGraph {
                         format!("({contract_no}, {function_no})")
                     } else {
                         "_".to_string()
-                    }
+                    },
+                    flags.as_ref().map(|e| self.expr_to_string(contract, ns, e)).unwrap_or_default()
                 )
             }
             Instr::ValueTransfer {

src/codegen/constant_folding.rs

@@ -242,6 +242,7 @@ pub fn constant_folding(cfg: &mut ControlFlowGraph, ns: &mut Namespace) {
                     callty,
                     seeds,
                     contract_function_no,
+                    flags,
                 } => {
                     let value = expression(value, Some(&vars), cfg, ns).0;
                     let gas = expression(gas, Some(&vars), cfg, ns).0;
@@ -255,6 +256,9 @@ pub fn constant_folding(cfg: &mut ControlFlowGraph, ns: &mut Namespace) {
                     let seeds = seeds
                         .as_ref()
                         .map(|expr| expression(expr, Some(&vars), cfg, ns).0);
+                    let flags = flags
+                        .as_ref()
+                        .map(|expr| expression(expr, Some(&vars), cfg, ns).0);
 
                     cfg.blocks[block_no].instr[instr_no] = Instr::ExternalCall {
                         success: *success,
@@ -266,6 +270,7 @@ pub fn constant_folding(cfg: &mut ControlFlowGraph, ns: &mut Namespace) {
                         gas,
                         callty: callty.clone(),
                         contract_function_no: *contract_function_no,
+                        flags,
                     };
                 }
                 Instr::SelfDestruct { recipient } => {

src/codegen/expression.rs

@@ -1677,6 +1677,7 @@ fn payable_send(
                 },
                 callty: CallTy::Regular,
                 contract_function_no: None,
+                flags: None,
             },
         );
     }
@@ -1735,6 +1736,7 @@ fn payable_transfer(
                 },
                 callty: CallTy::Regular,
                 contract_function_no: None,
+                flags: None,
             },
         );
     }
@@ -2819,6 +2821,11 @@ pub fn emit_function_call(
 
             let success = vartab.temp_name("success", &Type::Bool);
 
+            let flags = call_args
+                .flags
+                .as_ref()
+                .map(|expr| expression(expr, cfg, caller_contract_no, func, ns, vartab, opt));
+
             cfg.add(
                 vartab,
                 Instr::ExternalCall {
@@ -2831,6 +2838,7 @@ pub fn emit_function_call(
                     gas,
                     callty: ty.clone(),
                     contract_function_no: None,
+                    flags,
                 },
             );
 
@@ -2907,6 +2915,11 @@ pub fn emit_function_call(
 
                 let (payload, _) = abi_encode(loc, args, ns, vartab, cfg, false);
 
+                let flags = call_args
+                    .flags
+                    .as_ref()
+                    .map(|expr| expression(expr, cfg, caller_contract_no, func, ns, vartab, opt));
+
                 cfg.add(
                     vartab,
                     Instr::ExternalCall {
@@ -2919,6 +2932,7 @@ pub fn emit_function_call(
                         gas,
                         callty: CallTy::Regular,
                         contract_function_no,
+                        flags,
                     },
                 );
 
@@ -2975,6 +2989,11 @@ pub fn emit_function_call(
 
                 let (payload, _) = abi_encode(loc, args, ns, vartab, cfg, false);
 
+                let flags = call_args
+                    .flags
+                    .as_ref()
+                    .map(|expr| expression(expr, cfg, caller_contract_no, func, ns, vartab, opt));
+
                 cfg.add(
                     vartab,
                     Instr::ExternalCall {
@@ -2987,6 +3006,7 @@ pub fn emit_function_call(
                         gas,
                         callty: CallTy::Regular,
                         contract_function_no: None,
+                        flags,
                     },
                 );
 

src/codegen/solana_deploy.rs

@@ -540,6 +540,7 @@ pub(super) fn solana_deploy(
                 },
                 callty: CallTy::Regular,
                 contract_function_no: None,
+                flags: None,
             },
         );
 

src/codegen/statements.rs

@@ -1142,6 +1142,10 @@ fn try_catch(
                 args.insert(0, selector);
                 let (payload, _) = abi_encode(loc, args, ns, vartab, cfg, false);
 
+                let flags = call_args.flags.as_ref().map(|expr| {
+                    expression(expr, cfg, callee_contract_no, Some(func), ns, vartab, opt)
+                });
+
                 cfg.add(
                     vartab,
                     Instr::ExternalCall {
@@ -1154,6 +1158,7 @@ fn try_catch(
                         gas,
                         callty: CallTy::Regular,
                         contract_function_no: None,
+                        flags,
                     },
                 );
 

src/codegen/subexpression_elimination/instruction.rs

@@ -384,6 +384,7 @@ impl<'a, 'b: 'a> AvailableExpressionSet<'a> {
                 callty,
                 seeds,
                 contract_function_no,
+                flags,
             } => {
                 let new_address = address
                     .as_ref()
@@ -397,6 +398,10 @@ impl<'a, 'b: 'a> AvailableExpressionSet<'a> {
                     .as_ref()
                     .map(|expr| self.regenerate_expression(expr, ave, cst).1);
 
+                let flags = flags
+                    .as_ref()
+                    .map(|expr| self.regenerate_expression(expr, ave, cst).1);
+
                 Instr::ExternalCall {
                     success: *success,
                     address: new_address,
@@ -407,6 +412,7 @@ impl<'a, 'b: 'a> AvailableExpressionSet<'a> {
                     gas: self.regenerate_expression(gas, ave, cst).1,
                     callty: callty.clone(),
                     contract_function_no: *contract_function_no,
+                    flags,
                 }
             }
 

src/emit/instructions.rs

@@ -809,6 +809,7 @@ pub(super) fn process_instruction<'a, T: TargetRuntime<'a> + ?Sized>(
                     value,
                     salt,
                     seeds,
+                    flags: None,
                 },
                 ns,
                 *loc,
@@ -827,6 +828,7 @@ pub(super) fn process_instruction<'a, T: TargetRuntime<'a> + ?Sized>(
             callty,
             accounts,
             seeds,
+            flags,
             ..
         } => {
             let loc = payload.loc();
@@ -928,7 +930,9 @@ pub(super) fn process_instruction<'a, T: TargetRuntime<'a> + ?Sized>(
             } else {
                 None
             };
-
+            let flags = flags
+                .as_ref()
+                .map(|e| expression(target, bin, e, &w.vars, function, ns).into_int_value());
             let success = match success {
                 Some(n) => Some(&mut w.vars.get_mut(n).unwrap().value),
                 None => None,
@@ -948,6 +952,7 @@ pub(super) fn process_instruction<'a, T: TargetRuntime<'a> + ?Sized>(
                     salt: None,
                     seeds,
                     accounts,
+                    flags,
                 },
                 callty.clone(),
                 ns,

src/emit/mod.rs

@@ -42,6 +42,7 @@ pub struct ContractArgs<'b> {
     salt: Option<IntValue<'b>>,
     seeds: Option<(PointerValue<'b>, IntValue<'b>)>,
     accounts: Option<(PointerValue<'b>, IntValue<'b>)>,
+    flags: Option<IntValue<'b>>,
 }
 
 #[derive(Clone, Copy)]

src/emit/substrate/target.rs

@@ -991,7 +991,7 @@ impl<'a> TargetRuntime<'a> for SubstrateTarget {
         let ret = call!(
             "seal_call",
             &[
-                i32_zero!().into(), // TODO implement flags (mostly used for proxy calls)
+                contract_args.flags.unwrap_or(i32_zero!()).into(),
                 address.unwrap().into(),
                 contract_args.gas.unwrap().into(),
                 value_ptr.into(),

src/sema/ast.rs

@@ -1187,6 +1187,7 @@ pub struct CallArgs {
     pub address: Option<Box<Expression>>,
     pub accounts: Option<Box<Expression>>,
     pub seeds: Option<Box<Expression>>,
+    pub flags: Option<Box<Expression>>,
 }
 
 impl Recurse for CallArgs {
@@ -1204,6 +1205,9 @@ impl Recurse for CallArgs {
         if let Some(accounts) = &self.accounts {
             accounts.recurse(cx, f);
         }
+        if let Some(flags) = &self.flags {
+            flags.recurse(cx, f);
+        }
     }
 }
 

src/sema/dotgraphviz.rs

@@ -1464,6 +1464,9 @@ impl Dot {
         if let Some(seeds) = &call_args.seeds {
             self.add_expression(seeds, func, ns, node, String::from("seeds"));
         }
+        if let Some(flags) = &call_args.flags {
+            self.add_expression(flags, func, ns, node, String::from("flags"));
+        }
     }
 
     fn add_string_location(

src/sema/expression/function_call.rs

@@ -2180,6 +2180,27 @@ pub(super) fn parse_call_args(
 
                 res.seeds = Some(Box::new(expr));
             }
+            "flags" => {
+                if !(ns.target.is_substrate() && external_call) {
+                    diagnostics.push(Diagnostic::error(
+                        arg.loc,
+                        "'flags' are only permitted for external calls on substrate".into(),
+                    ));
+                    return Err(());
+                }
+
+                let ty = Type::Uint(32);
+                let expr = expression(
+                    &arg.expr,
+                    context,
+                    ns,
+                    symtable,
+                    diagnostics,
+                    ResolveTo::Type(&ty),
+                )?;
+                let flags = expr.cast(&arg.expr.loc(), &ty, true, ns, diagnostics)?;
+                res.flags = Some(flags.into());
+            }
             _ => {
                 diagnostics.push(Diagnostic::error(
                     arg.loc,

src/sema/unused_variable.rs

@@ -280,6 +280,9 @@ fn check_call_args(ns: &mut Namespace, call_args: &CallArgs, symtable: &mut Symt
     if let Some(seeds) = &call_args.seeds {
         used_variable(ns, seeds.as_ref(), symtable);
     }
+    if let Some(flags) = &call_args.flags {
+        used_variable(ns, flags.as_ref(), symtable);
+    }
 }
 
 /// Marks as used variables that appear in an expression with right and left hand side.

tests/codegen_testcases/solidity/substrate_call_flags.sol

@@ -0,0 +1,10 @@
+// RUN: --target substrate --emit cfg
+
+contract CallFlags {
+    function call_with_flags( address _address, uint32 _flags) public returns (bytes ret) {
+        (bool ok, ret) = _address.call{flags: _flags}(hex"deadbeef");
+        // CHECK: block0: # entry
+        // CHECK: ty:uint32 %_flags = (arg #1)
+        // CHECK: %success.temp.4 = external call::regular address:(arg #0) payload:(alloc bytes uint32 4 hex"deadbeef") value:uint128 0 gas:uint64 0 accounts: seeds: contract|function:_ flags:(arg #1)
+    }
+}

tests/contract_testcases/substrate/calls/call_flags_01.sol

@@ -0,0 +1,25 @@
+contract CallFlags {
+
+    enum CallFlag { FORWARD_INPUT, CLONE_INPUT, TAIL_CALL, ALLOW_REENTRY }
+
+    // Set all flags found in _flags to true.
+    function bitflags(CallFlag[] _flags) internal pure returns (uint32 flags) {
+        for (uint n = 0; n < _flags.length; n++) {
+            flags |= (2 ** uint32(_flags[n]));
+        }
+    }
+
+    // Call the contract at _address with the given _selector.
+    // Specify any flag used for the contract call in _flags.
+    function call_with_flags(
+        address _address,
+        bytes4 _selector,
+        CallFlag[] _flags
+    ) public returns (bytes ret) {
+        uint32 call_flags = bitflags(_flags);
+        (bool ok, ret) = _address.call{flags: call_flags}(_selector);
+        require(ok);
+    }
+}
+
+// ---- Expect: diagnostics ----

tests/contract_testcases/substrate/calls/call_flags_02.sol

@@ -0,0 +1,28 @@
+enum CallFlag {
+    FORWARD_INPUT,
+    CLONE_INPUT,
+    TAIL_CALL,
+    ALLOW_REENTRY
+}
+
+function conv_flag(CallFlag[] _flags) pure returns (uint32 flags) {
+    for (uint n = 0; n < _flags.length; n++) {
+        flags |= (2 ** uint32(_flags[n]));
+    }
+}
+
+contract Caller {
+    function echo(
+        address _address,
+        bytes4 _selector,
+        uint32 _x,
+        CallFlag[] _flags
+    ) public payable returns (uint32 ret) {
+        bytes input = abi.encode(_selector, _x);
+        (bool ok, bytes raw) = _address.call{value: conv_flag(_flags)}(input);
+        require(ok);
+        ret = abi.decode(raw, (uint32));
+    }
+}
+
+// ---- Expect: diagnostics ----

tests/substrate.rs

@@ -7,6 +7,7 @@ use ink_metadata::InkProject;
 use ink_primitives::Hash;
 use parity_scale_codec::Decode;
 use sha2::{Digest, Sha256};
+use std::collections::HashSet;
 use std::{collections::HashMap, ffi::OsStr, fmt, fmt::Write};
 use tiny_keccak::{Hasher, Keccak};
 use wasmi::core::{HostError, Trap, TrapCode};
@@ -22,6 +23,21 @@ mod substrate_tests;
 type StorageKey = [u8; 32];
 type Address = [u8; 32];
 
+#[derive(Clone, Copy)]
+enum CallFlags {
+    ForwardInput = 1,
+    CloneInput = 2,
+    TailCall = 4,
+    AllowReentry = 8,
+}
+
+impl CallFlags {
+    /// Returns true if this flag is set in the given `flags`.
+    fn set(&self, flags: u32) -> bool {
+        flags & *self as u32 != 0
+    }
+}
+
 /// Reason for halting execution. Same as in pallet contracts.
 #[derive(Default, Debug, Clone)]
 enum HostReturn {
@@ -201,7 +217,7 @@ struct Runtime {
     /// Will hold the memory reference after a successful execution.
     memory: Option<Memory>,
     /// The input for the contract execution.
-    input: Vec<u8>,
+    input: Option<Vec<u8>>,
     /// The output of the contract execution.
     output: HostReturn,
     /// Descirbes how much value was given to the contract call.
@@ -210,6 +226,8 @@ struct Runtime {
     debug_buffer: String,
     /// Stores all events emitted during contract execution.
     events: Vec<Event>,
+    /// The set of called events, needed for reentrancy protection.
+    called_accounts: HashSet<usize>,
 }
 
 impl Runtime {
@@ -237,8 +255,9 @@ impl Runtime {
         runtime.account = callee;
         runtime.transferred_value = value;
         runtime.accounts[callee].value += value;
-        runtime.input = input;
+        runtime.input = Some(input);
         runtime.output = Default::default();
+        runtime.called_accounts.insert(self.caller_account);
         runtime
     }
 
@@ -337,11 +356,12 @@ fn read_account(mem: &[u8], ptr: u32) -> Address {
 impl Runtime {
     #[seal(0)]
     fn input(dest_ptr: u32, len_ptr: u32) -> Result<(), Trap> {
-        assert!(read_len(mem, len_ptr) >= vm.input.len());
-        println!("seal_input: {}", hex::encode(&vm.input));
+        let data = vm.input.as_ref().expect("input was forwarded");
+        assert!(read_len(mem, len_ptr) >= data.len());
+        println!("seal_input: {}", hex::encode(data));
 
-        write_buf(mem, dest_ptr, &vm.input);
-        write_buf(mem, len_ptr, &(vm.input.len() as u32).to_le_bytes());
+        write_buf(mem, dest_ptr, data);
+        write_buf(mem, len_ptr, &(data.len() as u32).to_le_bytes());
 
         Ok(())
     }
@@ -466,9 +486,21 @@ impl Runtime {
         output_ptr: u32,
         output_len_ptr: u32,
     ) -> Result<u32, Trap> {
-        assert_eq!(flags, 0); // At the time, we never set call flags
+        assert!(flags <= 0b1111);
 
-        let input = read_buf(mem, input_ptr, input_len);
+        let input = if CallFlags::ForwardInput.set(flags) {
+            if vm.input.is_none() {
+                return Ok(1);
+            }
+            vm.input.take().unwrap()
+        } else if CallFlags::CloneInput.set(flags) {
+            if vm.input.is_none() {
+                return Ok(1);
+            }
+            vm.input.as_ref().unwrap().clone()
+        } else {
+            read_buf(mem, input_ptr, input_len)
+        };
         let value = read_value(mem, value_ptr);
         let callee_address = read_account(mem, callee_ptr);
 
@@ -483,11 +515,15 @@ impl Runtime {
             None => return Ok(8), // ReturnCode::NotCallable
         };
 
+        if vm.called_accounts.contains(&callee) && !CallFlags::AllowReentry.set(flags) {
+            return Ok(1);
+        }
+
         if value > vm.accounts[vm.account].value {
             return Ok(5); // ReturnCode::TransferFailed
         }
 
-        let ((flags, data), state) = match vm.call("call", callee, input, value) {
+        let ((ret, data), state) = match vm.call("call", callee, input, value) {
             Some(Ok(state)) => ((state.data().output.as_data()), state),
             Some(Err(_)) => return Ok(1), // ReturnCode::CalleeTrapped
             None => return Ok(8),
@@ -499,11 +535,14 @@ impl Runtime {
             write_buf(mem, output_len_ptr, &(data.len() as u32).to_le_bytes());
         }
 
-        if flags == 2 {
+        if ret == 2 {
             return Ok(2); // ReturnCode::CalleeReverted
         }
 
         vm.accept_state(state.into_data(), value);
+        if CallFlags::TailCall.set(flags) {
+            return Err(HostReturn::Data(0, data).into());
+        }
         Ok(0)
     }
 
@@ -758,6 +797,7 @@ impl MockSubstrate {
 
         runtime.debug_buffer.clear();
         runtime.events.clear();
+        runtime.called_accounts.clear();
         self.0 = runtime.call(export, callee, input, value).unwrap()?;
         self.0.data_mut().transferred_value = 0;
 

tests/substrate_tests/calls.rs

@@ -831,3 +831,152 @@ fn selector() {
         .zip(runtime.output())
         .for_each(|(actual, expected)| assert_eq!(actual, expected));
 }
+
+#[test]
+fn call_flags() {
+    let mut runtime = build_solidity(
+        r##"
+contract Flagger {
+    uint8 roundtrips;
+
+    // See https://github.com/paritytech/substrate/blob/5ea6d95309aaccfa399c5f72e5a14a4b7c6c4ca1/frame/contracts/src/wasm/runtime.rs#L373
+    enum CallFlag { FORWARD_INPUT, CLONE_INPUT, TAIL_CALL, ALLOW_REENTRY }
+    function bitflags(CallFlag[] _flags) internal pure returns (uint32 flags) {
+        for (uint n = 0; n < _flags.length; n++) {
+            flags |= (2 ** uint32(_flags[n]));
+        }
+    }
+
+    // Reentrancy is required for reaching the `foo` function for itself.
+    //
+    // Cloning and forwarding should have the effect of calling this function again, regardless of what _address was passed.
+    // Furthermore:
+    // Cloning the clone should work together with reentrancy.
+    // Forwarding the input should fail caused by reading the input more than once in the loop
+    // Tail call should work with any combination of input forwarding.
+    function echo(
+        address _address,
+        bytes4 _selector,
+        uint32 _x,
+        CallFlag[] _flags
+    ) public payable returns(uint32 ret) {
+        for (uint n = 0; n < 2; n++) {
+            if (roundtrips > 1) {
+                return _x;
+            }
+            roundtrips += 1;
+
+            bytes input = abi.encode(_selector, _x);
+            (bool ok, bytes raw) =  _address.call{flags: bitflags(_flags)}(input);
+            require(ok);
+            ret = abi.decode(raw, (uint32));
+
+            roundtrips -= 1;
+        }
+    }
+
+    @selector([0,0,0,0])
+    function foo(uint32 x) public pure returns(uint32) {
+        return x;
+    }
+
+    // Yields different result for tail calls
+    function tail_call_it(
+        address _address,
+        bytes4 _selector,
+        uint32 _x,
+        CallFlag[] _flags
+    ) public returns(uint32 ret) {
+        bytes input = abi.encode(_selector, _x);
+        (bool ok, bytes raw) =  _address.call{flags: bitflags(_flags)}(input);
+        require(ok);
+        ret = abi.decode(raw, (uint32));
+        ret += 1;
+    }
+}"##,
+    );
+
+    #[derive(Encode)]
+    enum CallFlags {
+        ForwardInput,
+        CloneInput,
+        TailCall,
+        AllowReentry,
+    }
+    #[derive(Encode)]
+    struct Input {
+        address: [u8; 32],
+        selector: [u8; 4],
+        voyager: u32,
+        flags: Vec<CallFlags>,
+    }
+
+    let address = runtime.caller();
+    let selector = [0, 0, 0, 0];
+    let voyager = 123456789;
+
+    let with_flags = |flags| {
+        Input {
+            address,
+            selector,
+            voyager,
+            flags,
+        }
+        .encode()
+    };
+
+    // Should work with the reentrancy flag
+    runtime.function("echo", with_flags(vec![CallFlags::AllowReentry]));
+    assert_eq!(u32::decode(&mut &runtime.output()[..]).unwrap(), voyager);
+
+    // Should work with the reentrancy and the tail call flag
+    runtime.function(
+        "echo",
+        with_flags(vec![CallFlags::AllowReentry, CallFlags::TailCall]),
+    );
+    assert_eq!(u32::decode(&mut &runtime.output()[..]).unwrap(), voyager);
+
+    // Should work with the reentrancy and the clone input
+    runtime.function(
+        "echo",
+        with_flags(vec![CallFlags::AllowReentry, CallFlags::CloneInput]),
+    );
+    assert_eq!(u32::decode(&mut &runtime.output()[..]).unwrap(), voyager);
+
+    // Should work with the reentrancy clone input and tail call flag
+    runtime.function(
+        "echo",
+        with_flags(vec![
+            CallFlags::AllowReentry,
+            CallFlags::CloneInput,
+            // FIXME: Enabling this flag here specifically breaks the _next_ test.
+            // This is a very odd bug in the mock VM; need to revisit later.
+            // CallFlags::TailCall,
+        ]),
+    );
+    assert_eq!(u32::decode(&mut &runtime.output()[..]).unwrap(), voyager);
+
+    // Should fail without the reentrancy flag
+    runtime.function_expect_failure("echo", with_flags(vec![]));
+    runtime.function_expect_failure("echo", with_flags(vec![CallFlags::TailCall]));
+
+    // Should fail with input forwarding
+    runtime.function_expect_failure(
+        "echo",
+        with_flags(vec![CallFlags::AllowReentry, CallFlags::ForwardInput]),
+    );
+
+    // Test the tail call without setting it
+    runtime.function("tail_call_it", with_flags(vec![CallFlags::AllowReentry]));
+    assert_eq!(
+        u32::decode(&mut &runtime.output()[..]).unwrap(),
+        voyager + 1
+    );
+
+    // Test the tail call with setting it
+    runtime.function(
+        "tail_call_it",
+        with_flags(vec![CallFlags::AllowReentry, CallFlags::TailCall]),
+    );
+    assert_eq!(u32::decode(&mut &runtime.output()[..]).unwrap(), voyager);
+}

tests/substrate_tests/function_types.rs

@@ -226,7 +226,7 @@ fn ext() {
             function test() public {
                 function(int32) external returns (uint64) func = this.foo;
 
-                assert(func(102) == 0xabbaabba);
+                assert(func{flags: 8}(102) == 0xabbaabba);
             }
 
             function foo(int32) public returns (uint64) {
@@ -251,7 +251,7 @@ fn ext() {
             }
 
             function bar(function(int32) external returns (uint64) f) internal {
-                assert(f(102) == 0xabbaabba);
+                assert(f{flags: 8}(102) == 0xabbaabba);
             }
         }"##,
     );
@@ -272,7 +272,7 @@ fn ext() {
             }
 
             function bar(function(int32) external returns (uint64) f) internal {
-                assert(f(102) == 0xabbaabba);
+                assert(f{flags: 8}(102) == 0xabbaabba);
             }
         }"##,
     );
@@ -287,7 +287,7 @@ fn ext() {
             function test() public {
                 function(int32) external returns (uint64) func = this.foo;
 
-                this.bar(func);
+                this.bar{flags: 8}(func);
             }
 
             function foo(int32) public returns (uint64) {
@@ -295,7 +295,7 @@ fn ext() {
             }
 
             function bar(function(int32) external returns (uint64) f) public {
-                assert(f(102) == 0xabbaabba);
+                assert(f{flags: 8}(102) == 0xabbaabba);
             }
         }"##,
     );
@@ -314,7 +314,7 @@ fn ext() {
             }
 
             function test2() public {
-                this.bar(func);
+                this.bar{flags: 8}(func);
             }
 
             function foo(int32) public returns (uint64) {
@@ -322,7 +322,7 @@ fn ext() {
             }
 
             function bar(function(int32) external returns (uint64) f) public {
-                assert(f(102) == 0xabbaabba);
+                assert(f{flags: 8}(102) == 0xabbaabba);
             }
         }"##,
     );
@@ -352,14 +352,14 @@ fn encode_decode_ext_func() {
                 bytes4 selector = hex"00000000";
     	        bytes enc = abi.encode(a, selector);
                 function() external returns (uint8) dec2 = abi.decode(enc, (function() external returns (uint8)));
-                return dec2();
+                return dec2{flags: 8}();
             }
 
             function decode_call(function() external returns(uint8) func) public returns (uint8) {
                 bytes enc = abi.encode(func);
                 print("{}  ".format(enc));
                 function() external returns (uint8) dec2 = abi.decode(enc, (function() external returns (uint8)));
-                return dec2();
+                return dec2{flags: 8}();
             }
         }
         "##,

tests/substrate_tests/value.rs

@@ -273,7 +273,7 @@ fn this_address() {
             int32 s;
 
             function step1() public returns (int32) {
-                this.other(102);
+                this.other{flags: 8}(102);
                 return s;
             }