More Motoko parentheticals: try _bounded-wait_ calls in local replicas now!

Developers Motoko
1

GM Motokoders!

I have just released Motoko v0.14.2 extending the parentheticals syntax to message sends. This now lets one to set cycles to be sent and also to activate bounded-wait messaging (formerly known as “best effort”) using (with timeout = <seconds>). Please note, though, that this latter feature is not active on mainnet just yet, with subnets being enabled successively. For local development with dfx you are all set.

To give a timeline, we’ll deprecate Cycles.add<system> in one of the upcoming releases of the 0.14.x series, nudging users to use (with cycles) instead. At some later point (0.15.0) we’ll remove the legacy interface. The new base library probably won’t even contain Cycles.add…

You are invited to test the new features and bugfixes either in the Playground or in an upcoming dfx version 0.25.1 -beta.1 final (not out yet now released). Of course you can also download it directly from the release page and use it with env DFX_MOC_PATH ... on the CLI. Also, don’t forget to bump your VSCode Motoko extension to get the new type checker in the IDE.

We are happy to receive feedback and bug reports (well, hopefully not) from early adopters.

Thanks for your support and keep having Motoko fun,

— The Languages Team

8 Likes
2

Maybe I should motivate why we chose the (with cycles) way of attaching cycles and why Cycles.add was an inferior idea.

First Cycles.add is/was a base library and compiler primitive that accumulates cycles in a private variable and attaches the current total to the call that comes next. Especially the occurrences of these two may be very distant in your (or someone else’s) source code, which opens up the possibility of supply-chain attacks and may drain your cycles balance by having a tactically placed message send to an unrelated canister snuck in by a library update.

By strictly joining the cycle attachment to the call in the Motoko syntax, such shenanigans are not possible any more (assuming proper audit), making security reviews more predicable and thus securing the Motoko canisters programmed in this new fashion.

Please refer to the programmer’s manual about the full feature description of parentheticals for syntax and usage.

2 Likes
3

Can you give us a bit of sample code of what these will look like in practice?

1 Like
4

Sure, but it is not much more than what is in the release notes!

This is an excerpt from the regression tests (and suitably modified):

Receiver side

import Cycles = "mo:base/ExperimentalCycles";
import { print } = "mo:base/Debug";
import { replyDeadline } = "mo:base/ExperimentalInternetComputer";

actor A {
    public func ext() : async () {
        assert 0 != replyDeadline();
        print ("ext: " # debug_show(Cycles.available()))
    }
};

Sender side

import A = "canister:a";

actor B {
    public func test() : async () {
        await (with timeout = 3; cycles = 6543) A.ext()
    }
}

For bounded-wait messages the usual caveats apply:

  • message may (or may not) have arrived at destination canister
  • sender must detect new error code #system_unknown and retry
  • receiver must deal with idempotency issues
  • refund of cycles may not happen (use small cycle amounts only).

Check the OP YouTube link for a better picture.

5

@ggreif

Is there a way for a called function to know if it was called with a timeout? ie. “If I got this too late I can just dump it”.

1 Like
6

Yes, from the base library CHANGELOG.md:

## 0.14.3

* Added `isRetryPossible : Error -> Bool` to `Error` (#692).
* Made `ExperimentalInternetComputer.replyDeadline` to return
  an optional return type (#693).

...

## 0.13.5

* Added `Text.fromList` and `Text.toList` functions (#676).

* Added `Text.fromArray` and `Text.fromVarArray` functions (#674).

* Added `replyDeadline` to `ExperimentalInternetComputer` (#677).

(replyDeadline is also available as a primitive if you have an older dfx/moc.) Note that before 0.14.3 (i.e. an upcoming dfx) it returned a Nat and you had to check if it is zero (meaning no deadline). Sorry for the inconvenience!

2 Likes
7

The return is a utc timestamp in nanos?

8

Sure. Just like Time.mo’s.

1 Like