Reference

An archetype contract is composed of declarations, actions (aka entry points) and optionally specification for formal verification.

Declarations

constant and variables declare global variables. A constant value cannot be modified in the contract's actions.

constant rate : rational = 0.2

variable price : tez = 10tz

states declares contract's possible states. It is then possible to use transitions to change the contract states (see below)

states =
| Created initial
| Confirmed
| Canceled
| Success
| Fail

initial is used to declare the initial state value of the contract.

action declares an entry point of the contract. An action has the following sections:
- specification (optional) to provide the post conditions the action is supposed to have
- accept transfer (optional) to specify that transfer of tez is accepted
- called by (optional) to declare which role may call this action
- require (optional) to list the necessary conditions for the action to be executed
- failif (optional)to list the conditions which prevent from execution
- effect is the code to execute by the action

action an_action_1 (arg1 : string, arg2 : int) {
  specification {
    // see 'specification' section below
  }
  called by a_role
  require {
    r1 : arg2 > 0 
  }
  failif {
    f1 : arg2 > 10
  }
  effect {
    // ...
  }
}

transition declares an entry point of the contract that changes the state of the contract. A transition has the same sections as an action (except effect, see above) plus:
- from to specify the states the transition starts from
- to to specify the states after the transition
- when (optional) to specify the transition condition
- with effect to specify the effect of the transition

states 
| Created initial
| Confirmed
| Canceled
| Success
| Fail

transition confirm {
  from Created
  to Confirmed
  when { transferred > 10 tz }
  with effect {
    transfer 1tz to @tz1RNB9PXsnp7KMkiMrWNMRzPjuefSWojBAm
  }
}

It is possible to specify several to ... when .... with effect ... sections in a transition. It is possible to specify a list of original states for the transition to start from:

transition fail {
  from Created or Confirmed
  to Fail
  when { ... }
}

Builtin types

bool : boolean values
int : integer values
rational : floating value that can be expressed as the quotient or fraction of two integers
address : account address
role : an address that can be used in action's called by section
date : date values
duration : duration values (in second, minute, hour, day, week)
string : string of characters
tez : Tezos currency
bytes : bytes sequence

Composite types

* declares a tuple made of other types.

constant pair : int * string = (1, "astr")

option declares an option of type.

constant value : int option = none

list declares a list of any type (builtin or composed)

variable vals : string list = []

asset declares a collection of asset and the data an asset is composed of. For example the following declares a collection of real estates described by an address, a location and an owner:

asset real_estate identified by addr {
  addr : string;
  xlocation : string;
  ylocation : string;
  owner : address;
}

enum declares an enumeration value. It is read with a match ... with command (see below).

enum color =
| White 
| Red
| Green
| Blue

It is then possible to declare a variable of type color:

variable c : color = Green

contract declares the signature of another existing contract to call in actions.

contract called_contract_sig {
   action set_value (n : int)
   action add_value (a : int, b : int)
}

It is then possible to declare a contract value of type called_contract_sig and set its address:

constant c : called_contract_sig = @KT1RNB9PXsnp7KMkiMrWNMRzPjuefSWojBAm

collection declares an asset field as a collection of another asset.

asset an_asset identified by id {
  id : string;
  a_val : int;
  asset_col : another_asset collection
}

partition declares an asset field as a collection of another asset. The difference with collection is that a partition ensures at compilation that every partitioned asset (i.e. element of the partition) belongs to one and only partitioning asset.

asset partitioning_asset identified by id {
  id : string;
  asset_part : partitioned_asset partition;
}

As a consequence of the partition, a partitioned asset cannot be straightforwardly added or removed to its global collection with add and remove (see operation below). This has to be done via a partition field:

my_partitioning_asset.asset_part.add(a_new_partitioned_asset)

Effect

An action's effect is composed of instructions separated by a semi-colon.

Declaration

var declares a local variable with its value. While possible, it is not necessary to declare the type a local variable. Local variables' identifier must be unique (no name capture in Archetype).

var i = 0;

Assignment

:= enables to assign a new value to a global or local variable.

i := 1;

+= , -= , *= and /= enable to respectively increment and decrement an integer variable (local or global).

i *= 2;  // i := i * 2
d += 3w; // d := i + 3w, date d is now previous d plus 3 weeks

Effects on asset collection

add enables to add an asset to an asset collection. It fails if the asset key is already present in the collection.

an_asset.add({ id = "RJRUEQDECSTG", asset_col = [] }); // see 'collection' example

update enables to update an existing asset; it takes as arguments the id of the asset to update and the list of effects on the asset. It fails if the id is not present in the asset collection.

an_asset.update("RJRUEQDECSTG", { a_value += 3 });

addupdate is similar to update except that it adds the asset if its identifier is not present in the collection.

an_asset.addupdate("RJRUEQDECSTG", { a_value += 3 });

remove removes a an asset from its collection.

an_asset.remove("RJRUEQDECSTG");

removeif enables removing assets under a condition.

an_asset.removeif(a_val > 10); // "a_val" is an asset field

clear clears an asset collection.

an_asset.clear();

Control

; sequence

res := 1;
res := 2;
res := 3;

if then and if then else are the conditional branchings instructions.

if i > 0 then (
  // (* effect when i > 0 *) 
) else (
  // (* effect when i <= 0 *)
);

match ... with ... end FIXME

archetype effect_control_matchwith

enum t =
  | C1
  | C2
  | C3
  | C4
  | C5

variable res : int = 0

action exec () {
  specification {
    s0: res = 1;
  }
  effect {
    var x : t = C3;
    match x with
    | C1 | C2 -> res := 0
    | C3 -> res := 1
    | _ -> res := 2
    end
  }
}

for in do done iterates over a collection.

 var res = 0;
 for a in an_asset do
   res += a.a_val;
 done;

iter to do done iterates over a sequence of integer values (starting from 1).

var res = 0
iter i to 3 do      // iterates from 1 to 3 included
  res += i;
done;               // res is 6

transfer transfers an amount of tez to an address or a contract.

transfer 2tz to @tz1RNB9PXsnp7KMkiMrWNMRzPjuefSWojBAm;

With the contract keyword presented above, it is possible to transfer to a contract and call an entry point. In the example below, the entry point set_value of contract c is called and 2tz is transferred.

contract contract_called_sig {
   action set_value (n : int)
   action add_value (a : int, b : int)
}

constant c : called_contract_sig = @KT1RNB9PXsnp7KMkiMrWNMRzPjuefSWojBAm

action update_value(n : int) {
  effect {
    transfer 2tz to c call set_value(n);
  }
}

fail aborts the execution. It prevents from deploying the contract on the blockchain. As a consequence the storage is left unchanged when executed.

fail("a message");

require and failif fail if the argument condition is respectively false and true. require(t) is sugar for if t then fail("").

require(val > 0);
failif(val <= 0);

Expressions

Literals

boolean

constant x : bool = true
constant y : bool = false

integer

constant i : int = 1
constant j : int = -42

rational

constant f : rational = 1.1
constant g : rational = -1.1
constant r : rational = 2 div 6
constant t : rational = -2 div 6

string

constant s : string = "hello world"

tez

constant ctz  : tez = 1tz
constant cmtz : tez = 1mtz
constant cutz : tez = 1utz

address / role

constant a : address = @tz1Lc2qBKEWCBeDU8npG6zCeCqpmaegRi6Jg

duration

// duration of 3 weeks 8 days 4 hours 34 minutes 18 seconds
constant d : duration = 3w8d4h34m18s

date

constant date0 : date = 2019-01-01                
constant date1 : date = 2019-01-01T01:02:03       
constant date2 : date = 2019-01-01T01:02:03Z      
constant date3 : date = 2019-01-01T00:00:00+01:00 
constant date4 : date = 2019-01-01T00:00:00-05:30

list

constant mylist : int list = [1; 2; 3]

option

constant op1 : int option = none
constant op2 : int option = some(0)

bytes

constant bl : bytes = 0x12f12354356a

Operators

Logical

and operator of logical conjunction

var bool_bool_and : bool = (true and false);

or operator of logical disjunction

var bool_bool_or  : bool = (true or false);

not operator of logical negation

var bool_bool_not : bool = not true;

Operator

= FIXME

var int_int_eq   : bool = 1 = 2;
var rat_int_eq   : bool = (1 div 2) = 2;
var int_rat_eq   : bool = 1 = (2 div 3);
var rat_rat_eq   : bool = (1 div 3) = (2 div 3);
var tez_tez_eq   : bool = 1tz = 2tz;
var dur_dur_eq   : bool = 1h = 2h;
var date_date_eq : bool = 2020-01-01 = 2020-12-31;
var bool_bool_eq : bool = true = false;
var addr_addr_eq : bool = @tz1Lc2qBKEWCBeDU8npG6zCeCqpmaegRi6Jg = @tz1bfVgcJC4ukaQSHUe1EbrUd5SekXeP9CWk;
var str_str_eq   : bool = "a" = "b";

<> FIXME

var int_int_ne   : bool = 1 <> 2;
var rat_int_ne   : bool = (1 div 2) <> 2;
var int_rat_ne   : bool = 1 <> (2 div 3);
var rat_rat_ne   : bool = (1 div 2) <> (2 div 3);
var tez_tez_ne   : bool = 1tz <> 2tz;
var dur_dur_ne   : bool = 1h <> 2h;
var date_date_ne : bool = 2020-01-01 <> 2020-12-31;
var bool_bool_ne : bool = true <> false;
var addr_addr_ne : bool = @tz1Lc2qBKEWCBeDU8npG6zCeCqpmaegRi6Jg <> @tz1bfVgcJC4ukaQSHUe1EbrUd5SekXeP9CWk;
var str_str_ne   : bool = "a" <> "b";

< FIXME

var int_int_lt   : bool = 1 < 2;
var rat_int_lt   : bool = (1 div 2) < 2;
var int_rat_lt   : bool = 1 < (2 div 3);
var rat_rat_lt   : bool = (1 div 2) < (2 div 3);
var tez_tez_lt   : bool = 1tz < 2tz;
var dur_dur_lt   : bool = 1h < 2h;
var date_date_lt : bool = 2020-01-01 < 2020-12-31;

<= FIXME

var int_int_le   : bool = 1 <= 2;
var rat_int_le   : bool = (1 div 2) <= 2;
var int_rat_le   : bool = 1 <= (2 div 3);
var rat_rat_le   : bool = (1 div 2) <= (2 div 3);
var tez_tez_le   : bool = 1tz <= 2tz;
var dur_dur_le   : bool = 1h <= 2h;
var date_date_le : bool = 2020-01-01 <= 2020-12-31;

> FIXME

var int_int_gt   : bool = 1 > 2;
var rat_int_gt   : bool = (1 div 2) > 2;
var int_rat_gt   : bool = 1 > (2 div 3);
var rat_rat_gt   : bool = (1 div 2) > (2 div 3);
var tez_tez_gt   : bool = 1tz > 2tz;
var dur_dur_gt   : bool = 1h > 2h;
var date_date_gt : bool = 2020-01-01 > 2020-12-31;

>= FIXME

var int_int_ge   : bool = 1 >= 2;
var rat_int_ge   : bool = (1 div 2) >= 2;
var int_rat_ge   : bool = 1 >= (2 div 3);
var rat_rat_ge   : bool = (1 div 2) >= (2 div 3);
var tez_tez_ge   : bool = 1tz >= 2tz;
var dur_dir_ge   : bool = 1h >= 2h;
var date_date_ge : bool = 2020-01-01 >= 2020-12-31;

Arithmetic

+ FIXME

var int_int_plus   : int      = 1 + 2;
var rat_rat_plus   : rational = 1.1 + 1.2;
var int_rat_plus   : rational = 1 + 1.2;
var rat_int_plus   : rational = 1.1 + 2;
var dur_dur_plus   : duration = 1h + 2s;
var date_dur_plus  : date     = 2020-01-01 + 1d;
var dur_date_plus  : date     = 1d + 2020-01-01;
var str_str_plus   : string   = "str1" + "str2"; (* concat *)
var tez_tez_plus   : tez      = 2tz + 1tz;

- FIXME

var int_int_minus   : int       = 1 - 2;
var rat_rat_minus   : rational  = 1.1 - 1.2;
var int_rat_minus   : rational  = 1 - 1.2;
var rat_int_minus   : rational  = 1.1 - 2;
var date_date_minus : duration  = 2020-01-01 - 2019-12-31; (* absolute value *)
var dur_dur_minus   : duration  = 1h - 2s; (* absolute value *)
var date_dur_minus  : date      = 2020-01-01 - 1d;
var tez_tez_minus   : tez       = 2tz - 1tz;

* FIXME

var int_int_mult   : int      = 1 * 2;
var rat_rat_mult   : rational = 1.1 * 1.2;
var int_rat_mult   : rational = 1 * 1.2;
var rat_int_mult   : rational = 1.1 * 2;
var int_dur_mult   : duration = 2 * 1h;
var int_tez_mult   : tez      = 1 * 1tz;
var rat_tez_mult   : tez      = 1.1 * 1tz;

/ FIXME

var int_int_div    : int = 1 / 2;
var rat_rat_div    : rational = 1.1 / 1.2;
var int_rat_div    : rational = 1 / 1.2;
var rat_int_div    : rational = 1.1 / 2;
var dur_int_div    : duration = 1h / 2;

% FIXME

var int_int_modulo : int = 1 % 2;

Constant

caller FIXME

var v : address = caller; (* SENDER *)

source FIXME

var v : address = source; (* SOURCE *)

balance FIXME

var v : tez = balance; (* BALANCE *)

transferred FIXME

var v : tez = transferred; (* AMOUNT *)

now FIXME

var v : date = now; (* NOW *)

state FIXME

archetype sample_state

states =
| First
| Second
| Third


transition mytr () {
  from First
  to Second
  with effect {
    require (state = First)
  }
}

Builtin functions

min FIXME

var int_int_min   : int  = min(1, 2);
var rat_int_min   : rat  = min(1 div 2, 1);
var int_rat_min   : rat  = min(2, 1 div 3);
var rat_rat_min   : rat  = min(1 div 2, 1 div 3);
var date_date_min : date = min(2020-01-01, 2020-12-31);
var dur_dur_min   : dur  = min(1h, 1s);
var tez_tez_min   : tez  = min(1tz, 2tz);

max FIXME

var int_int_max   : int  = max(1, 2);
var rat_int_max   : rat  = max(1 div 2, 1);
var int_rat_max   : rat  = max(2, 1 div 3);
var rat_rat_max   : rat  = max(1 div 2, 1 div 3);
var date_date_max : date = max(2020-01-01, 2020-12-31);
var dur_dur_max   : dur  = max(1h, 1s);
var tez_tez_max   : tez  = max(1tz, 2tz);

abs FIXME

var int_abs : int = abs(-1);
var rat_abs : rat = abs(-1 div 2);

List

contains FIXME

archetype expr_list_contains

variable res : bool = false

action exec () {
  specification {
    s0: res = true;
  }
  effect {
    var l : string list = ["1"; "2"; "3"];
    res := contains(l, "2")
  }
}

count FIXME

archetype expr_list_count

variable res : int = 0

action exec () {
  specification {
    s0: res = 3;
  }
  effect {
    var l : string list = ["1"; "2"; "3"];
    res := count(l)
  }
}

nth FIXME

archetype expr_list_nth

variable res : string = ""

action exec () {
  specification {
    s0: res = "2";
  }
  effect {
    var l : string list = ["1"; "2"; "3"];
    res := nth(l, 1)
  }
}

prepend adds an element to a list at the first position.

archetype expr_list_prepend

variable res : string list = []

action exec () {
  specification {
    s0: res = ["0"; "1"; "2"; "3"];
  }
  effect {
    var l : string list = ["1"; "2"; "3"];
    res := prepend(l, "0");
  }
}

Asset Collection

contains FIXME

archetype expr_method_asset_contains

asset my_asset identified by id {
  id : string;
  value : int;
} initialized by {
  {"id0"; 0};
  {"id1"; 1};
  {"id2"; 2}
}

variable res : bool = false

action exec () {
  specification {
    s0: res = true;
  }
  effect {
    res := my_asset.contains("id0")
  }
}

count FIXME

archetype expr_method_asset_count

asset my_asset identified by id {
  id : string;
  value : int;
} initialized by {
  {"id0"; 0};
  {"id1"; 1};
  {"id2"; 2}
}

variable res : int = 0

action exec () {
  specification {
    s0: res = 3;
  }
  effect {
    res := my_asset.count()
  }
}

get FIXME

archetype expr_method_asset_get

asset my_asset identified by id {
  id : string;
  value : int;
} initialized by {
  {"id0"; 0};
  {"id1"; 1};
  {"id2"; 2}
}

variable res : int = 0

action exec () {
  specification {
    s0: res = 1;
  }
  effect {
    var a = my_asset.get("id1");
    res := a.value
  }
}

nth FIXME

archetype expr_method_asset_nth

asset my_asset identified by id {
  id : string;
  value : int;
} initialized by {
  {"id0"; 0};
  {"id1"; 1};
  {"id2"; 2}
}

variable res : int = 0

action exec () {
  specification {
    s0: res = 1;
  }
  effect {
    var a = my_asset.nth(1);
    res := a.value
  }
}

head FIXME

archetype expr_method_asset_head

asset my_asset identified by id {
  id : string;
  value : int;
} initialized by {
  {"id0"; 4};
  {"id1"; 3};
  {"id2"; 2}
}

variable res : int = 0

action exec () {
  specification {
    s0: res = 3;
  }
  effect {
    var l = my_asset.head(2);
    var a = l.nth(1);
    res := a.value
  }
}

tail FIXME

archetype expr_method_asset_tail

asset my_asset identified by id {
  id : string;
  value : int;
} initialized by {
  {"id0"; 0};
  {"id1"; 1};
  {"id2"; 2}
}

variable res : int = 0

action exec () {
  specification {
    s0: res = 1;
  }
  effect {
    var l = my_asset.tail(2);
    var a = l.nth(0);
    res := a.value
  }
}

select FIXME

archetype expr_method_asset_select

asset my_asset identified by id {
  id : string;
  value : int;
} initialized by {
  {"id0"; 0};
  {"id1"; 1};
  {"id2"; 2}
}

variable res : int = 0

action exec () {
  specification {
    s0: res = 2;
  }
  effect {
    var l = my_asset.select(the.id = "id2");
    var a = l.nth(0);
    res := a.value
  }
}

sort FIXME

archetype expr_method_asset_sort

asset my_asset identified by id {
  id : string;
  value : int;
} initialized by {
  {"id0"; 3};
  {"id1"; 2};
  {"id2"; 1}
}

variable res : int = 0

action exec () {
  specification {
    s0: res = 1;
  }
  effect {
    var l = my_asset.sort(value);
    var a = l.nth(0);
    res := a.value
  }
}

you can also sort with several criteria

archetype multi_sort

asset my_asset identified by id {
  id : string;
  v1 : int;
  v2 : int;
  v3 : int;
} initialized by {
  {"id0"; 1; 2; 7};
  {"id1"; 1; 3; 9};
  {"id2"; 1; 3; 8};
  {"id3"; 1; 2; 6}
}

action exec () {

  effect {
    var res = my_asset.sort(v1, asc(v2), desc (v3))
    (* res = ["id0"; "id3", "id1", "id2"] *)
  }
}

sum FIXME

archetype expr_method_asset_sum

asset my_asset identified by id {
  id : string;
  value : int;
} initialized by {
  {"id0"; 0};
  {"id1"; 1};
  {"id2"; 2}
}

variable res : int = 0

action exec () {
  specification {
    s0: res = 3;
  }
  effect {
    res := my_asset.sum(value)
  }
}

Verification

Specification

Here is a full example with all sections of an action specification

archetype contract_with_full_specification

asset myasset {
  id: string;
  val: bool;
}

asset col1 {
  id1 : string;
}

asset col2 {
  id2 : string;
}

action exec () {
 specification {

    definition mydef {
      x : myasset | forall y in col1, x.id = y.id1
    }

    predicate mypredicate (a : int) {
      forall x in col1, forall y in col2, x.id1 = y.id2
    }

    variable myvar : int = 0

    shadow effect {
      myvar := 3
    }

    assert a1 {
      x = y
      invariant for myloop {
        x = 0;
        y = 0
      }
    }

    postcondition s1 {
      x = y
      invariant for myloop {
        x = 0;
        y = 0
      }
    }
  }

  effect {
    var x : int = 0;
    var y : int = 0;
    for : myloop c in col1 do
      require(true)
    done;
    assert a1
  }
}

definition FIXME

definition mydef {
  x : myasset | forall y in col1, x.id = y.id1
}

predicate FIXME

predicate mypredicate (a : int) {
  forall x in col1, forall y in col2, x.id1 = y.id2
}

variable FIXME

variable myvar : int = 0

shadow effect FIXME

shadow effect {
  myvar := 3
}

assert FIXME

assert a1 {
  x = y
  invariant for myloop {
    x = 0;
    y = 0
  }
}

invariant FIXME

invariant for myloop {
  x = 0;
  y = 0
}

postcondition FIXME

postcondition s1 {
  x = y
  invariant for myloop {
    x = 0;
    y = 0
  }
}

One specification section is available at the top of the contract. But there is neither shadow effect nor postcondition, which is replaced by contract invariant for the last one.

contract invariant FIXME

contract invariant c1 {
  true <> false
}

Expression

All expression in effect are available in formula part.

forall universal quantifier

q1: forall x : int, x = x;
q2: forall x in my_asset, x.value = x.value;

exists existential quantifier

q3: exists x : int, x = x;
q4: exists x in my_asset, x.value = x.value;

-> imply

o1: true -> true;

<-> equivalence

o2: true <-> true;

Asset expression

subsetof FIXME

archetype expr_formula_asset_method_subset

asset my_asset identified by id {
  id : string;
  value : int;
} initialized by {
  {"id0"; 0};
  {"id1"; 1};
  {"id2"; 2}
}

action exec () {

  specification {
    s: my_asset.subsetof(my_asset);
  }

  effect {
    require (true)
  }
}

isempty FIXME

archetype expr_formula_asset_method_isempty

asset my_asset identified by id {
  id : string;
  value : int;
} initialized by {
  {"id0"; 0};
  {"id1"; 1};
  {"id2"; 2}
}

action exec () {

  specification {
    s: my_asset.isempty();
  }

  effect {
    require (true)
  }
}

Extra asset collection

before FIXME

s1: before.my_asset.isempty();

at FIXME

s2: at(lbl).my_asset.isempty();

unmoved FIXME

s3: my_asset.unmoved.isempty();

added FIXME

s4: my_asset.added.isempty();

removed FIXME

s5: my_asset.removed.isempty();

iterated FIXME

action exec2 () {
  specification {
    postcondition p1 {
      true
      invariant for loop {
         iterated.isempty()
      }
    }
  }

  effect {
    var res : int = 0;
    for:loop i in my_asset do
      res += 1;
    done
  }
}

toiterate FIXME

action exec3 () {
  specification {
    postcondition p1 {
      true
      invariant for loop {
         toiterate.isempty() 
      }
    }
  }

  effect {
    var res : int = 0;
    for:loop i in my_asset do
      res += 1;
    done
  }
}

Security predicate

archetype lang_security

constant admin : role = @tz1aazS5ms5cbGkb6FN1wvWmN7yrMTTcr6wB

asset my_asset identified by id {
  id : string;
  value : int;
}

action exec () {
  effect {
    require true
  }
}

security {
  s00 : only_by_role (anyaction, admin);
  s01 : only_in_action (anyaction, exec);
  s02 : only_by_role_in_action (anyaction, admin, exec);
  s03 : not_by_role (anyaction, admin);
  s04 : not_in_action (anyaction, exec);
  s05 : not_by_role_in_action (anyaction, admin, exec);
  s06 : transferred_by (anyaction);
  s07 : transferred_to (anyaction);
  s08 : no_storage_fail (anyaction);
}

only_by_role FIXME

s00 : only_by_role (anyaction, admin);

only_in_action FIXME

s01 : only_in_action (anyaction, exec);

only_by_role_in_action FIXME

s02 : only_by_role_in_action (anyaction, admin, exec);

not_by_role FIXME

s03 : not_by_role (anyaction, admin);

not_in_action FIXME

s04 : not_in_action (anyaction, exec);

not_by_role_in_action FIXME

s05 : not_by_role_in_action (anyaction, admin, exec);

transferred_by FIXME

s06 : transferred_by (anyaction);

transferred_to FIXME

s07 : transferred_to (anyaction);

no_storage_fail FIXME

s08 : no_storage_fail (anyaction);

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Reference

Declarations

Builtin types

Composite types

Effect

Declaration

Assignment

Effects on asset collection

Control

Expressions

Literals

Operators

Logical

Operator

Arithmetic

Constant

Builtin functions

List

Asset Collection

Verification

Specification

Expression

Asset expression

Extra asset collection

Security predicate

FilesExpand file tree

archetype-reference.md

Latest commit

History

archetype-reference.md

File metadata and controls

Reference

Declarations

Builtin types

Composite types

Effect

Declaration

Assignment

Effects on asset collection

Control

Expressions

Literals

Operators

Logical

Operator

Arithmetic

Constant

Builtin functions

List

Asset Collection

Verification

Specification

Expression

Asset expression

Extra asset collection

Security predicate