resolver.scilla

scilla_version 0

import BoolUtils

library ResolverLib

type RecordKeyValue =
  | RecordKeyValue of String String

let nilMessage = Nil {Message}

let oneMsg =
  fun(msg: Message) =>
    Cons {Message} msg nilMessage

let eOwnerSet =
  fun(address: ByStr20) =>
    {_eventname: "OwnerSet"; address: address}

let eRecordsSet =
  fun(registry: ByStr20) =>
  fun(node: ByStr32) =>
    {_eventname: "RecordsSet"; registry: registry; node: node}

let eError =
  fun(message: String) =>
    {_eventname: "Error"; message: message}

let emptyValue = ""

let mOnResolverConfigured = 
  fun(registry: ByStr20) => 
  fun(node: ByStr32) => 
    let m = {_tag: "onResolverConfigured"; _amount: Uint128 0; _recipient: registry; node: node} in
      oneMsg m

let copyRecordsFromList =
  fun (recordsMap: Map String String) =>
  fun (recordsList: List RecordKeyValue) =>
    let foldl = @list_foldl RecordKeyValue Map String String in
      let iter =
        fun (recordsMap: Map String String) =>
        fun (el: RecordKeyValue) =>
          match el with
          | RecordKeyValue key val =>
            let isEmpty = builtin eq val emptyValue in
              match isEmpty with
              | True => builtin remove recordsMap key
              | False => builtin put recordsMap key val
              end
          end
      in
        foldl iter recordsMap recordsList

contract Resolver(
  initialOwner: ByStr20,
  registry: ByStr20,
  node: ByStr32,
  initialRecords: Map String String
)
field vendor: String = "UD"
field version: String = "0.1.1"
field owner: ByStr20 = initialOwner
field records: Map String String = initialRecords

(* Sets owner address *)
(* @ensures a sender address is an owner of the contract *)
(* @param address *)
(* @emits OwnerSet if the operation was successful *)
(* @emits Error if a sender address has no permission for the operation *)
transition setOwner(address: ByStr20)
  currentOwner <- owner;
  isOkSender = builtin eq currentOwner _sender;
  match isOkSender with
  | True =>
    owner := address;
    e = eOwnerSet address;
    event e
  | _ =>
    e = let m = "Sender not owner" in eError m;
    event e
  end
end

(* Sets a key value pair *)
(* @ensures a sender address is an owner of the contract *)
(* @param key *)
(* @param value *)
(* @emits RecordSet if the operation was successful *)
(* @emits Error if a sender address has no permission for the operation *)
(* @sends onResolverConfigured to the registry *)
transition set(key: String, value: String)
  currentOwner <- owner;
  isOkSender = builtin eq currentOwner _sender;
  match isOkSender with
  | True =>
    isEmpty = builtin eq value emptyValue;
    match isEmpty with
    | True => delete records[key]
    | False => records[key] := value
    end;
    e = eRecordsSet registry node;
    event e;
    msgs = mOnResolverConfigured registry node;
    send msgs
  | _ =>
    e = let m = "Sender not owner" in eError m;
    event e
  end
end

(* Remove a key from records map *)
(* @ensures a sender address is an owner of the contract *)
(* @param key *)
(* @emits RecordUnset if the operation was successful *)
(* @emits Error if a sender address has no permission for the operation *)
(* @sends onResolverConfigured to the registry *)
transition unset(key: String)
  keyExists <- exists records[key];
  currentOwner <- owner;
  isOk = 
    let isOkSender = builtin eq currentOwner _sender in
      andb isOkSender keyExists;
  match isOk with
  | True =>
    delete records[key];
    e = eRecordsSet registry node;
    event e;
    msgs = mOnResolverConfigured registry node;
    send msgs
  | _ =>
    e = let m = "Sender not owner or key does not exist" in 
      eError m;
    event e
  end
end


(* Set multiple keys to records map *)
(* Removes records from the map if according passed value is empty *)
(* @ensures a sender address is an owner of the contract *)
(* @param newRecords *)
(* @emits RecordsSet if the operation was successful *)
(* @emits Error if a sender address has no permission for the operation *)
(* @sends onResolverConfigured to the registry *)
transition setMulti(newRecords: List RecordKeyValue)
  currentOwner <- owner;
  isOkSender = builtin eq currentOwner _sender;
  match isOkSender with
  | True =>
    oldRecords <- records;
    newRecordsMap = copyRecordsFromList oldRecords newRecords;
    records := newRecordsMap;
    e = eRecordsSet registry node;
    event e;
    msgs = mOnResolverConfigured registry node;
    send msgs
  | _ =>
    e = let m = "Sender not owner" in eError m;
    event e
  end
end