WASM Move Calls

[UMR1352]

Description of change

Port all calls to move functions to TS using IOTA's TS SDK and bind these move calls through WASM into iota_interaction_ts package.

Links to any relevant issues

Closes #1449

Type of change

• Bug fix (a non-breaking change which fixes an issue)
• Enhancement (a non-breaking change which adds functionality)
• Breaking change (fix or feature that would cause existing functionality to not work as expected)
• Documentation Fix

How the change has been tested

Huge trust me bro as the project is not yet compilable.

[chrisgitiota]

I'll definitely need some more hours to deep dive into this PR especially for my personal favorite check this out 👍 🤩

One request from my side would be to change the target branch to feat/identity-rebased-alpha. The branch feat/wasm32-develop-alpha has already been merged into it and will be deleted probably next week (it only still exists, because I wanted to maintain the purged commit messages for a while).

[UMR1352]

Here some more context to better explain the hack used in the implementation of user-driven move-calls.

WASM bindgen allows to pass Rust closures to JS, but it only accepts Fn or FnMut closures. The intent function we receive from the user is neither of these two types and is in fact a FnOnce closure. The reason behind this is that FnOnce better fit the use case we have with "intent function" i.e., a pure function that is called exactly once.
Therefore, in order to make WASM bindgen happy, the intent function we receive has to become either a Fn or FnMut. Since we don't really care about modifying the captured context, Fn is a better fit.
Changing the type of intent function is not straightforward, the function traits cannot be manually implemented in stable Rust and using std::mem::transmute can't really help in this case.
The only way around this is to construct a new closure that implements Fn and that calls our intent_fn for us.
Though, this is not as straight forward as doing:

let f = || intent_fn(...);

since intent_fn is a FnOnce, invoking it with (...) also consumes it (see FnOnce::call_once and therefore the compiler will make f: FnOnce as well.

In order for f to be Fn it has to access all captured variables through shared references only, but FnOnce cannot be called through a reference.

Cell to the rescue! By wrapping intent_fn in Cell we can move it inside closure f through a shared reference:

let wrapped_fn = Cell::new(Some(intent_fn)); // We wrap it in an Option to leverage its Default implementation.
let f = || {
  wrapped_fn
    .take() // only requires shared access to self and moves out its content i.e. Option<impl FnOnce>
    .unwrap() // returns an impl FnOnce
    (...); // invokes and consumes `intent_fn`
};

The compiler will infer impl Fn for f and we can then pass it to WASM bindgen.