<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<dict>
    <entry key="blockstrategy">
        <dict>
            <entry key="name">
                <string>net.postchain.base.BaseBlockBuildingStrategy</string>
            </entry>
        </dict>
    </entry>
    <entry key="configurationfactory">
        <string>net.postchain.gtx.GTXBlockchainConfigurationFactory</string>
    </entry>
    <entry key="gtx">
        <dict>
            <entry key="modules">
                <array>
                    <string>net.postchain.rell.module.RellPostchainModuleFactory</string>
                    <string>net.postchain.gtx.StandardOpsGTXModule</string>
                </array>
            </entry>
            <entry key="rell">
                <dict>
                    <entry key="moduleArgs">
                        <dict>
                            <entry key="lib.ft3.core">
                                <dict>
                                    <entry key="my_blockchain_description">
                                        <string>Decentralized reddit</string>
                                    </entry>
                                    <entry key="my_blockchain_name">
                                        <string>Chromunity</string>
                                    </entry>
                                    <entry key="my_blockchain_website">
                                        <string>testnet.chromunity.com</string>
                                    </entry>
                                    <entry key="rate_limit_active">
                                        <int>1</int>
                                    </entry>
                                    <entry key="rate_limit_max_points">
                                        <int>5</int>
                                    </entry>
                                    <entry key="rate_limit_points_at_account_creation">
                                        <int>3</int>
                                    </entry>
                                    <entry key="rate_limit_recovery_time">
                                        <int>600000</int>
                                    </entry>
                                </dict>
                            </entry>
                        </dict>
                    </entry>
                    <entry key="modules">
                        <array>
                            <string></string>
                        </array>
                    </entry>
                    <entry key="sources_v0.10">
                        <dict>
                            <entry key="channel/index.rell">
                                <string>import user;
import topic;

entity channel {
    key name, topic.topic;
    index timestamp;
    display_name: name;
}

entity channel_following {
    key user.user, name;
}
</string>
                            </entry>
                            <entry key="channel/operations.rell">
                                <string>import user;

operation follow_channel(username: text, descriptor_id: byte_array, name) {
    val user = user.get_verified_user(username, descriptor_id);
    create channel_following(user, name.lower_case());
}

operation unfollow_channel(username: text, descriptor_id: byte_array, name) {
    val user = user.get_verified_user(username, descriptor_id);
    delete channel_following@{ user, name.lower_case()};
}</string>
                            </entry>
                            <entry key="channel/queries.rell">
                                <string>import user;
import topic;

query get_topics_by_channel_prior_to_timestamp(name, timestamp, page_size: integer) {
    val topics = channel@*{
        .name == name,
        .topic.last_modified &lt; timestamp
    } (
        id = .topic.id,
        author = .topic.author.display_name,
        title = .topic.title,
        message = .topic.message,
        timestamp = .topic.timestamp,
        @sort_desc last_modified = .topic.last_modified
    ) limit page_size;
    
    val ext_topics = list&lt;topic.ext_topic&gt;();
    for (t in topics) {
    	val moderated_by = topic.topic_moderation@*{ .topic.id == t.id } ( .user.name );
    	val ext_t = topic.ext_topic (
			id = t.id,
			author = t.author,
			title = t.title,
			message = t.message,
			timestamp = t.timestamp,
			last_modified = t.last_modified,
			latest_poster = topic.get_latest_poster_in_topic(t.id, t.author),
			moderated_by = moderated_by
		);
    	ext_topics.add(ext_t);
    }
    
    return ext_topics;
}

query get_topics_by_channel_after_timestamp(name, timestamp) {
    val topics = channel@*{
        .name == name,
        .topic.last_modified &gt; timestamp
    } (
        id = .topic.id,
        author = .topic.author.display_name,
        title = .topic.title,
        message = .topic.message,
        timestamp = .topic.timestamp,
        @sort_desc last_modified = .topic.last_modified
    );
    
    val ext_topics = list&lt;topic.ext_topic&gt;();
    for (t in topics) {
    	val moderated_by = topic.topic_moderation@*{ .topic.id == t.id } ( .user.name );
    	val ext_t = topic.ext_topic (
			id = t.id,
			author = t.author,
			title = t.title,
			message = t.message,
			timestamp = t.timestamp,
			last_modified = t.last_modified,
			latest_poster = topic.get_latest_poster_in_topic(t.id, t.author),
			moderated_by = moderated_by
		);
    	ext_topics.add(ext_t);
    }
    
    return ext_topics;
}

query count_topics_by_channel(name) {
    return channel@*{ .name == name } ( .name ).size();
}

query count_channel_followers(name) {
    return channel_following@*{ .name == name } ( .user.name ).size();
}

query get_topics_by_followed_channels_prior_to_timestamp(username: text, timestamp, page_size: integer) {
    val user = user.user@{ .name == username};
    val topics = (channel, channel_following)@*{
        channel_following.user == user,
        channel_following.name == channel.name,
        channel.topic.last_modified &lt; timestamp
    }
    (
        id = channel.topic.id,
        author = channel.topic.author.display_name,
        title = channel.topic.title,
        message = channel.topic.message,
        timestamp = channel.topic.timestamp,
        @sort_desc last_modified = channel.topic.last_modified
    ) limit page_size;
    
    val ext_topics = list&lt;topic.ext_topic&gt;();
    for (t in topics) {
    	val moderated_by = topic.topic_moderation@*{ .topic.id == t.id } ( .user.name );
    	val ext_t = topic.ext_topic (
			id = t.id,
			author = t.author,
			title = t.title,
			message = t.message,
			timestamp = t.timestamp,
			last_modified = t.last_modified,
			latest_poster = topic.get_latest_poster_in_topic(t.id, t.author),
			moderated_by = moderated_by
		);
    	ext_topics.add(ext_t);
    }
    
    return ext_topics;
}

query get_topics_by_followed_channels_after_timestamp(username: text, timestamp, page_size: integer) {
    val user = user.user@{ .name == username};
    val topics = (channel, channel_following)@*{
        channel_following.user == user,
        channel_following.name == channel.name,
        channel.topic.last_modified &gt; timestamp
    }
    (
        id = channel.topic.id,
        author = channel.topic.author.display_name,
        title = channel.topic.title,
        message = channel.topic.message,
        timestamp = channel.topic.timestamp,
        @sort_desc last_modified = channel.topic.last_modified
    ) limit page_size;
    
    val ext_topics = list&lt;topic.ext_topic&gt;();
    for (t in topics) {
    	val moderated_by = topic.topic_moderation@*{ .topic.id == t.id } ( .user.name );
    	val ext_t = topic.ext_topic (
			id = t.id,
			author = t.author,
			title = t.title,
			message = t.message,
			timestamp = t.timestamp,
			last_modified = t.last_modified,
			latest_poster = topic.get_latest_poster_in_topic(t.id, t.author),
			moderated_by = moderated_by
		);
    	ext_topics.add(ext_t);
    }
    
    return ext_topics;
}

query get_followed_channels(username: text) {
    val user = user.user@{ .name == username};
    return channel_following@*{ user } ( .name );
}

query get_all_channels() {
    return channel@*{} ( .display_name );
}

query get_channels_since(timestamp) {
    return channel@*{ .timestamp &gt; timestamp }( .display_name );
}

query get_topic_channels_belongings(topic_id: text) {
    return channel@*{ topic.topic@{ .id == topic_id }} ( .display_name );
}
</string>
                            </entry>
                            <entry key="chat/index.rell">
                                <string>import user;

entity chat {
	key id: text;
	mutable title: text;
	timestamp;
}

entity chat_user {
	key user.user;
	rsa_pubkey: text;
}

entity chat_membership {
	key chat, member: chat_user;
	encrypted_chat_key: text;
	mutable last_opened: timestamp = 0;
}

entity chat_message {
	index chat;
	index sender: chat_user;
	index timestamp;
	encrypted_msg: text;
}

struct chat_record {
	id: text;
	title: text;
	last_message: message_record?;
	encrypted_chat_key: text;
	timestamp;
	last_opened: timestamp;
}

struct message_record {
	sender: name;
	timestamp;
	encrypted_msg: text;
}
</string>
                            </entry>
                            <entry key="chat/operations.rell">
                                <string>import user;
import util;

operation create_chat(chat_id: text, descriptor_id: byte_array, username: text, title: text, encrypted_chat_key: text) {
	val founder = user.get_verified_user(username, descriptor_id);

	val chat = create chat(id = chat_id, title = title, timestamp = op_context.last_block_time);
	create chat_membership(chat, chat_user@{ .user == founder }, encrypted_chat_key);
}

operation create_chat_user(descriptor_id: byte_array, username: text, rsa_pubkey: text) {
	val user = user.get_verified_user(username, descriptor_id);
	create chat_user(user, rsa_pubkey);
}

operation delete_chat_user(descriptor_id: byte_array, username: text) {
	val user = user.get_verified_user(username, descriptor_id);
	val chat_user = chat_user@?{ user };

	if (chat_user != null) {
		delete chat_membership@*{ .member == chat_user };
		delete chat_message@*{ .sender == chat_user };
		delete chat_user;
	}
}

operation add_user_to_chat(descriptor_id: byte_array, username: text, chat_id: text, target_user: text, encrypted_chat_key: text) {
	val user_already_in_chat = user.get_verified_user(username, descriptor_id);
	val chat = chat@{ .id == chat_id };

	if (chat_membership@?{ chat, .member.user.name == target_user.lower_case() } == null) {
		create chat_membership(chat, chat_user@{ .user.name == target_user.lower_case() }, encrypted_chat_key);
	}
}

operation leave_chat(descriptor_id: byte_array, username: text, chat_id: text) {
	val user = user.get_verified_user(username, descriptor_id);
	val chat = chat@{ .id == chat_id };

	delete chat_membership@{ chat, chat_user@{ user }};

	if (chat_membership@*{ chat } ( .member ).size() == 0) {
		delete chat_message@*{ chat };
		delete chat;
	}
}

operation modify_chat_title(descriptor_id: byte_array, username: text, chat_id: text, title: text) {
	val user = user.get_verified_user(username, descriptor_id);
	val chat = chat@{ .id == chat_id };
	chat_membership@{ chat, chat_user@{ user }};
	update chat(title = title);
}

operation send_chat_message(chat_id: text, descriptor_id: byte_array, username: name, encrypted_msg: text) {
	val user = user.get_verified_user(username, descriptor_id);

	val chat = chat@{ .id == chat_id };
	val chat_user = chat_user@{ user };
	val chat_member = chat_membership@?{ chat, chat_user };
	require(chat_member != null, util.app_error(util.error_type.USER_UNAUTHORIZED, "Only a chat member can send a message"));

	create chat_message(chat, chat_user, op_context.last_block_time, encrypted_msg);
}

operation update_last_opened_timestamp(chat_id: text, descriptor_id: byte_array, username: name) {
	val user = user.get_verified_user(username, descriptor_id);
	update chat_membership@{
		.chat.id == chat_id,
		.member.user == user
	} ( last_opened = op_context.last_block_time );
}
</string>
                            </entry>
                            <entry key="chat/queries.rell">
                                <string>import follow;

query get_chat_user_pubkey(username: name): text? {
	return chat_user@?{ .user.name == username.lower_case() } ( .rsa_pubkey );
}

query get_user_chats(username: name): list&lt;chat_record&gt; {

	val member_chats = chat_membership@*{ .member.user.name == username.lower_case() };
	val chat_records = list&lt;chat_record&gt;();

	for (member_chat in member_chats) {
		val latest_message = chat_message@?{ .chat == member_chat.chat } ( .sender, @sort_desc .timestamp, .encrypted_msg, @sort_desc .chat.timestamp ) limit 1;

		if (latest_message != null) {
			val message = message_record(sender = latest_message.sender.user.display_name, timestamp = latest_message.timestamp, encrypted_msg = latest_message.encrypted_msg);
			chat_records.add(chat_record(
				id = member_chat.chat.id,
				title = member_chat.chat.title,
				last_message = message,
				encrypted_chat_key = member_chat.encrypted_chat_key,
				timestamp = member_chat.chat.timestamp,
				last_opened = member_chat.last_opened
			));
		} else {
			chat_records.add(chat_record(
				id = member_chat.chat.id,
				title = member_chat.chat.title,
				last_message = null,
				encrypted_chat_key = member_chat.encrypted_chat_key,
				timestamp = member_chat.chat.timestamp,
				last_opened = member_chat.last_opened
			));
		}

	}

	return chat_records;
}

query get_chat_messages(id: text, prior_to: timestamp, page_size: integer) {
	return chat_message@*{ .chat.id == id, .timestamp &lt; prior_to } (
		sender = chat_message.sender.user.display_name,
		@sort_desc timestamp = chat_message.timestamp,
		encrypted_msg = chat_message.encrypted_msg
	) limit page_size;
}

query get_chat_messages_after(id: text, after_timestamp: timestamp, page_size: integer) {
	return chat_message@*{ .chat.id == id, .timestamp &gt; after_timestamp } (
		sender = chat_message.sender.user.display_name,
		@sort timestamp = chat_message.timestamp,
		encrypted_msg = chat_message.encrypted_msg
	) limit page_size;
}

query get_chat_participants(id: text) {
	return chat_membership@*{ .chat.id == id } ( .member.user.display_name );
}

query get_followed_chat_users(username: name) {
	return (chat_user, follow.follow)@*{
		follow.follower.name == username.lower_case(),
		follow.follows == chat_user.user
	} ( chat_user.user.display_name );
}

query get_chat_users() {
	return chat_user@*{} ( chat_user.user.display_name );
}

query count_unread_chats(username: name) {
	val my_user = username.lower_case();
	return set&lt;chat&gt;((chat_membership, chat_message)@*{
		chat_membership.member.user.name == my_user,
		chat_message.timestamp &gt; chat_membership.last_opened,
		chat_membership.chat == chat_message.chat,
		chat_message.sender.user.name != my_user
	} ( chat_membership.chat )).size();
}</string>
                            </entry>
                            <entry key="election/index.rell">
                                <string>import user;
import topic;

entity representative_election {
    key id: integer;
    index timestamp;
    mutable completed: boolean;
    index completed;
}

entity election_block_details {
	key started_height: integer;
	mutable finished_height: integer = -1;
	index representative_election;
}

entity representative_election_candidate {
  key representative_election, user.user;
}

entity representative_election_vote {
    key user.user, representative_election_candidate;
}

entity temp_votes_counter {
	key representative_election_candidate;
	mutable votes: integer;
}

function is_eligible_to_vote(user.user): boolean {
	val prev_election_id = get_latest_completed_election_id();
	
	val current_election_id = get_current_election_id();
	
	if (current_election_id == null) {
		return false;
	} else if (prev_election_id == null) {
		return true;
	}
	
	val current_election_start = (election_block_details, block)@{ 
		election_block_details.representative_election.id == current_election_id,
		election_block_details.started_height == block.block_height
	} ( 
		block.timestamp
	);
	
	if (user.registered &gt; current_election_start) {
		log("Not elgible for voting: User registered after election start");
		return false; 
	}
	
	val previous_election_completed = (representative_election, election_block_details, block)@?{
		representative_election == election_block_details.representative_election,
		representative_election.completed == true,
		block.block_height == election_block_details.finished_height
	} ( 
		block.timestamp,
		@omit @sort_desc representative_election.timestamp
	) limit 1;
	
	if (previous_election_completed != null) {
		log("A previous election was held, so verifying correct number of posts");
		val number_of_topics = topic.topic@*{ 
			.author == user,
			.last_modified &gt; previous_election_completed,
			.last_modified &lt; current_election_start
		}( .id ).size();
		
		val number_of_replies = topic.topic_reply@*{
			.author == user,
			.timestamp &gt; previous_election_completed,
			.timestamp &lt; current_election_start
		}( .id ).size();
		
		return number_of_topics + number_of_replies &gt;= 5;
	}
	
	return true;
}

function governing_period_in_blocks(): integer {
	return 75000;
}

function election_duration_in_blocks(): integer {
	return 25000;
}

function get_current_election_id(): integer? {
	return representative_election@?{ .completed == false } ( @omit @sort_desc .timestamp, .id ) limit 1;
}

function get_latest_completed_election_id(): integer? {
	return representative_election@?{ .completed == true } ( .id, @omit @sort_desc .timestamp ) limit 1;
}</string>
                            </entry>
                            <entry key="election/operations.rell">
                                <string>import user;
import util;
import representative;

operation process_election() {
	var something_done = false;
	
	val current_block = op_context.block_height;
	val election_period_in_blocks = election_duration_in_blocks();
	val governing_period_in_blocks = governing_period_in_blocks();
	
	val election_block_details = election_block_details@?{} ( @sort_desc .started_height, .finished_height ) limit 1;
	
	if (election_block_details == null) {
		log("No election held yet, triggering new one");
		create_election_at_height(current_block);
		something_done = true;
	} else if (election_block_details.finished_height &gt;= 0 and election_block_details.finished_height + governing_period_in_blocks &lt; current_block) {
		log("Triggering a new election");
		create_election_at_height(current_block);
		something_done = true;
	} else if (election_block_details.finished_height == -1 
		and election_block_details.started_height + election_period_in_blocks &lt; current_block
	) {
		log("Wrapping up election");
		complete_election();
		something_done = true;
	}
	
	require(something_done, util.app_error(util.error_type.EXPECTED_ERROR, "Nothing done while processing of elections"));
}

function create_election_at_height(height: integer) {
	val election = create representative_election(
			id = height,
			timestamp = op_context.last_block_time, 
			false
		);
		create election_block_details(started_height = height, election);
}

function complete_election() {
	val current_election_id = require(get_current_election_id(), util.app_error(util.error_type.ILLEGAL_ACTION, "No on-going election"));
	
    val current_election = representative_election@{ .id == current_election_id };
    update current_election ( completed = true );
    update election_block_details@{ current_election } ( finished_height = op_context.block_height );
    
    val nr_of_participants = temp_votes_counter@*{} ( 
    	.representative_election_candidate.user.name
    ).size();
    
    val new_representatives = temp_votes_counter@*{ 
    	.representative_election_candidate.representative_election == current_election
    } (
    	@sort_desc @omit .votes,
    	.representative_election_candidate.user
    ) limit integer((nr_of_participants * 0.1).ceil());

    for (user in new_representatives) {
        create representative.representative(user, current_election);
    }
}

operation vote_for_candidate(voter: name, descriptor_id: byte_array, candidate: name) {
	require(voter != candidate, util.app_error(util.error_type.ILLEGAL_ACTION, "You can't vote for yourself"));
    val user = user.get_verified_user(voter, descriptor_id);

	require(is_eligible_to_vote(user), util.app_error(util.error_type.ILLEGAL_ACTION, "Not eligible for voting in the election"));

    val current_election_id = require(get_current_election_id(), util.app_error(util.error_type.ILLEGAL_ACTION, "No on-going election"));
    
    clean_up_votes(user, current_election_id);
    
    val vote = create representative_election_vote(
        user,
        representative_election_candidate@{ 
        	user.user@{ .name == candidate }, 
        	.representative_election.id == current_election_id
        }
    );
    
    update temp_votes_counter@ {
    	vote.representative_election_candidate
    } ( votes += 1 );
}

operation sign_up_for_election(name, descriptor_id: byte_array) {
    val user = user.get_verified_user(name, descriptor_id);
	val election_id = require(get_current_election_id(), util.app_error(util.error_type.ILLEGAL_ACTION, "No on-going election"));

    val candidate = create representative_election_candidate(
    	representative_election@{ .id == election_id }, 
    	user
    );
    
    create temp_votes_counter(candidate, 0);
}

function clean_up_votes(user.user, id: integer) {
	val old_candidate_votes = representative_election_vote@*{ 
    	user,
    	.representative_election_candidate.representative_election.id == id
    };
	for (old_candidate_vote in old_candidate_votes) {
	    
	    update temp_votes_counter@ {
	    	old_candidate_vote.representative_election_candidate
	    } ( votes -= 1 );
	    
	   	delete old_candidate_vote;
	}
}</string>
                            </entry>
                            <entry key="election/queries.rell">
                                <string>import user;
import util;

query eligible_for_voting(name): boolean {
	val user = user.user@{ .name == name.lower_case() };
	return is_eligible_to_vote(user);
}

query get_election_candidates() {
	val current_election_id = require(get_current_election_id(), util.app_error(util.error_type.ILLEGAL_ACTION, "No on-going election"));
	
    return temp_votes_counter@*{
        .representative_election_candidate.representative_election.id == current_election_id
    } ( 
    	@omit @sort_desc .votes,
    	.representative_election_candidate.user.display_name
    );
}

query get_next_election() {
    return representative_election@?{ .completed == false } ( .id, @sort_desc .timestamp ) limit 1;
}

query get_uncompleted_election() {
    return get_current_election_id();
}

query get_user_vote_in_election(name) {
	val current_election_id = require(get_current_election_id(), util.app_error(util.error_type.ILLEGAL_ACTION, "No on-going election"));
	
    return representative_election_vote@?{
        .user == user.user@{ .name == name },
        .representative_election_candidate.representative_election.id == current_election_id
    } ( .representative_election_candidate.user.name ) limit 1;
}

query get_current_representative_period(timestamp) {
    return representative_election @? { .timestamp &lt;= timestamp, .completed == true } ( .id, @sort_desc .timestamp ) limit 1;
}

query blocks_until_next_election() {
	val recent_election_finished = election_block_details@?{} ( 
		@omit @sort_desc .started_height, 
		.finished_height
	) limit 1;
	
	if (recent_election_finished == null) {
		return 0;
	}
	
	require(recent_election_finished != -1, "There is an ongoing election");
	
	val next_election_block = recent_election_finished + governing_period_in_blocks();
	
	var current_block = block@?{} ( @sort_desc .block_height ) limit 1;
	
	if (current_block == null) {
		current_block = 0;
	}
	
	return next_election_block - current_block;
}

query blocks_until_election_wraps_up() {
	val recent_election = election_block_details@{} ( 
		@sort_desc .started_height, 
		.finished_height
	) limit 1;
	
	require(recent_election.finished_height == -1, "There is no ongoing election");
	
	val election_finishing_block = recent_election.started_height + election_duration_in_blocks();
	
	var current_block = block@?{} ( @sort_desc .block_height ) limit 1;
	
	if (current_block == null) {
		current_block = 0;
	}
	
	return election_finishing_block - current_block;
}
</string>
                            </entry>
                            <entry key="follow/index.rell">
                                <string>import user;

entity follow {
    key follower: user.user, follows: user.user;
}
</string>
                            </entry>
                            <entry key="follow/operations.rell">
                                <string>import user;
import util;

operation create_following(follower: text, descriptor_id: byte_array, follows: text) {
    require(follower != follows, util.app_error(util.error_type.ILLEGAL_ACTION, "Follow another user"));
    val user = user.get_verified_user(follower, descriptor_id);
    create follow(follower = user, follows = user.user@{ .name == follows.lower_case() });
}

operation remove_following(follower: text, descriptor_id: byte_array, follows: text) {
    require(follower != follows, util.app_error(util.error_type.ILLEGAL_ACTION, "You can't unfollow yourself"));
    val user = user.get_verified_user(follower, descriptor_id);
    delete follow@{ .follower == user, .follows == user.user@{ .name == follows.lower_case() } };
}
</string>
                            </entry>
                            <entry key="follow/queries.rell">
                                <string>import user;

query get_user_followers(name) {
    return follow@*{ .follows == user.user @ { .name == name } }( .follower.name );
}

query get_user_follows(name) {
    return follow@*{ .follower == user.user@{ .name == name } } ( .follows.name );
}
</string>
                            </entry>
                            <entry key="lib/ft3/account/auth_basic.rell">
                                <string>// Auth type:

// "S" - single-sig
// "M" - multi-sig

struct single_sig_args {
       flags: set&lt;text&gt;;
       pubkey;
}

struct multi_sig_args {
       flags: set&lt;text&gt;;
       signatures_required: integer;
       pubkeys: list&lt;pubkey&gt;;
}

function check_single_sig_auth(args: byte_array, participants: list&lt;byte_array&gt;, required_flags: list&lt;text&gt;): boolean {
    require(participants.size() == 1);
    val ss_args = single_sig_args.from_bytes(args);
    return
          ss_args.flags.contains_all(required_flags)
            and
          is_signer(participants[0]);
}

function check_multi_sig_auth(args: byte_array, participants: list&lt;byte_array&gt;, required_flags: list&lt;text&gt;): boolean {
   val multi_sign_args = multi_sig_args.from_bytes(args);
   if (not (multi_sign_args.flags.contains_all(required_flags))) return false;
   var num_sign = multi_sign_args.signatures_required;
   for(s in participants) {
      if(is_signer(s)) {
          num_sign -= 1;
          if(num_sign &lt; 1) {return true;}
      }
   }
   return false;
}

function check_auth_args (a_t: text, args: byte_array, participants: list&lt;byte_array&gt;, required_flags: list&lt;text&gt;): boolean {
    return when (a_t) {
        "S" -&gt; check_single_sig_auth(args, participants, required_flags);
        "M" -&gt; check_multi_sig_auth(args, participants, required_flags);
        else -&gt; false;
    };
}



function require_auth (account, descriptor_id: byte_array, required_flags: list&lt;text&gt;) {
   val account_auth_descriptor = account_auth_descriptor @ {
     account,
     .descriptor_id == descriptor_id
   };
	
	require(is_valid(account_auth_descriptor));
	
   	require(
		check_auth_args(
       		account_auth_descriptor.auth_type,
       		account_auth_descriptor.args,
       		auth_descriptor_participant @* { account_auth_descriptor } ( .id ),
       		required_flags
		)
   );
   
   update_auth_descriptor_rule_variables(account_auth_descriptor);
   delete_expired_auth_descriptors(account);
}
</string>
                            </entry>
                            <entry key="lib/ft3/account/auth_descriptor_rule.rell">
                                <string>
enum rule_variable {
	block_height,
	block_time,
	op_count
}

enum rule_operator {
	lt,
	le,
	eq,
	ge,
	gt
}

struct rule_expression {
	variable: text;
	operator: text;
	value: gtv;
}

entity auth_descriptor_rule_variable {
	key account_auth_descriptor, name;
	mutable value: byte_array;
}

function is_valid(auth_descriptor: account_auth_descriptor): boolean {
	// check if rules is null (encoded null is equal to 0xa0020500)
	if (auth_descriptor.rules == x'a0020500') {
		return true;
	}
	
	return is_rule_valid(
		gtv.from_bytes(auth_descriptor.rules), 
		load_variables(auth_descriptor)
	);
}

function is_rule_valid(rule: gtv, variables: map&lt;text, gtv&gt;): boolean {
	val parameters = list&lt;gtv&gt;.from_gtv(rule);
	val operator = text.from_gtv(parameters[1]);
	
	if (operator == "and") {
		return handle_composed_rule(rule, variables);
	} else {
		return handle_single_rule(rule, variables);
	}
}

function handle_single_rule(rule: gtv, variables: map&lt;text, gtv&gt;): boolean {
	return evaluate_int_variable_rule(
		rule_expression.from_gtv(rule), 
		variables
	);	
}

 
function handle_composed_rule(rule: gtv, variables: map&lt;text, gtv&gt;): boolean {
	val parameters = list&lt;gtv&gt;.from_gtv(rule);
	val operator = text.from_gtv(parameters[1]);
	if (operator == "and") {
		return is_rule_valid(parameters[0], variables) and is_rule_valid(parameters[2], variables);
	} else {
		return false;
	}
}



function is_active(account_auth_descriptor): boolean {
	if (account_auth_descriptor.rules == x'a0020500') {
		return true;
	}
	
	return is_rule_active(gtv.from_bytes(account_auth_descriptor.rules), map&lt;text, gtv&gt;());
}


function is_rule_active(r: gtv, variables: map&lt;text, gtv&gt;): boolean {
	val parameters = list&lt;gtv&gt;.from_gtv(r);
	val operator = text.from_gtv(parameters[1]);
	when (operator) {
		"and" -&gt; {
			return is_rule_active(parameters[0], variables) and is_rule_active(parameters[2], variables);
		}
		else -&gt; {
			return is_simple_rule_active(r, variables);
		}
	}
}

function is_simple_rule_active(rule: gtv, variables: map&lt;text, gtv&gt;): boolean {
	val parameters = list&lt;gtv&gt;.from_gtv(rule);
	val variable_name = text.from_gtv(parameters[0]);
	when (rule_variable.value(variable_name)) {
		rule_variable.block_height -&gt; {
			return is_block_height_rule_active(rule);
		}
		rule_variable.block_time -&gt; {
			return is_block_time_rule_active(rule);
		}		
		rule_variable.op_count -&gt; {
			return is_op_count_rule_active(rule);
		}
	}
}

/*
 *  Variables
 */

function evaluate_int_variable_rule(rule: rule_expression, variables: map&lt;text, gtv&gt;): boolean {
	val variable = rule_variable.value(rule.variable);
	val operator = rule_operator.value(rule.operator);
	val current_value = variable_value(variable, variables);
	val defined_value = integer.from_gtv(rule.value);

	when (operator) {
		rule_operator.lt -&gt; {
			return current_value &lt; defined_value;
		}
		rule_operator.le -&gt; {
			return current_value &lt;= defined_value;
		}
		rule_operator.eq -&gt; {
			return current_value == defined_value;
		}
		rule_operator.ge -&gt; {
			return current_value &gt;= defined_value;
		}
		rule_operator.gt -&gt; {
			return current_value &gt; defined_value;
		}
	}
}


/*
 * Called from _add_auth_descriptor function
 */
function setup_auth_descriptor_variables(account_auth_descriptor) {
	
	if (account_auth_descriptor.rules == x'a0020500') {
		return;
	} 
	
	val variables = get_variable_names_set(gtv.from_bytes(account_auth_descriptor.rules));
	
	for (variable in variables) {
		when (variable) {
			rule_variable.op_count.name -&gt; {
				create auth_descriptor_rule_variable(
					account_auth_descriptor,
					name = variable,
					value = op_count_variable_initial_value().to_bytes()
				);
			}
		}
	}
}
 
function update_variables(account_auth_descriptor, variables: map&lt;text, gtv&gt;) {
	for ((name, value) in variables) {
		val variable = auth_descriptor_rule_variable @ { account_auth_descriptor, name };
		val int_value = integer.from_gtv(value);
		
		when (name) {
			rule_variable.op_count.name -&gt; {
				variable.value = (int_value + 1).to_gtv().to_bytes();
			}
		}
	}
}
 
function variable_value(variable: rule_variable, variables: map&lt;text, gtv&gt;): integer {
	when (variable) {
		rule_variable.block_height -&gt; {
			return op_context.block_height;
		}
		rule_variable.block_time -&gt; {
			return op_context.last_block_time;
		}
		rule_variable.op_count -&gt; {
			return integer.from_gtv(variables[rule_variable.op_count.name]);
		}
	}
}

/*
 * Analyze the rules before assigning them to an authenticator descriptor
 */
 function analyze_auth_descriptor_rules(rules: gtv, hop: integer) {
 	require(hop&lt;3, "too many rules");
 	val rules_bytes = rules.to_bytes(); 
 	if (rules_bytes == x'a0020500') {
		return;
	}
	
 	val params = list&lt;gtv&gt;.from_gtv(rules);
 	require(params.size() &lt;=3);
 	
 	val operator = text.from_gtv(params[1]);
 	if(operator == "and") {
 		analyze_auth_descriptor_rules(params[0], hop+1); 
 		analyze_auth_descriptor_rules(params[2], hop+1);
 	} 	
 	
	return;
 }

/*
 * Returns set of variable names used in a rule
 */
function get_variable_names_set(rules: gtv): set&lt;text&gt; {
	val parameters = list&lt;gtv&gt;.from_gtv(rules);
	val operator = text.from_gtv(parameters[1]);
	var vars = set&lt;text&gt;();
	if (operator == "and") {
		vars.add_all(get_variable_names_set(parameters[0]));
		vars.add_all(get_variable_names_set(parameters[2]));
	} else {
		vars.add(text.from_gtv(parameters[0]));
	}
	return vars;
} 

function load_variables(account_auth_descriptor): map&lt;text, gtv&gt; {
	val variables = auth_descriptor_rule_variable @* { account_auth_descriptor };
	
	val variables_map = map&lt;text, gtv&gt;();
	for (variable in variables) {
		variables_map[variable.name] = gtv.from_bytes(variable.value);
	}
	
	return variables_map;
}

function update_auth_descriptor_rule_variables(account_auth_descriptor) {
	val variables = load_variables(account_auth_descriptor);
	update_variables(account_auth_descriptor, variables);
}

/*
 * auth descriptor cleanup
 */

function delete_expired_auth_descriptors(account) {
	val auth_descriptors = account_auth_descriptor @* { account };
	
	for (auth_descriptor in auth_descriptors) {
		if (not (is_active(auth_descriptor) and is_valid(auth_descriptor))) {
			_delete_auth_descriptor(auth_descriptor);
		}
	}
}

/****************************************************************************************
 *                                     block_time                                       *
 ****************************************************************************************/

function is_block_time_rule_active(r: gtv): boolean {
	val parameters = list&lt;gtv&gt;.from_gtv(r);
	val operator = rule_operator.value(text.from_gtv(parameters[1]));
	val value = integer.from_gtv(parameters[2]);
	when (operator) {
		rule_operator.gt -&gt; {
			return op_context.last_block_time &gt; value;
		}
		rule_operator.ge,
		rule_operator.eq -&gt; {
			return op_context.last_block_time &gt;= value;
		}
		else -&gt; {
			return true;
		}
	}
}


/****************************************************************************************
 *                                  block_height                                        *
 ****************************************************************************************/

function is_block_height_rule_active(r: gtv): boolean {
	val parameters = list&lt;gtv&gt;.from_gtv(r);
	val operator = rule_operator.value(text.from_gtv(parameters[1]));
	val value = integer.from_gtv(parameters[2]);
	when (operator) {
		rule_operator.gt -&gt; {
			return op_context.block_height &gt; value;
		}
		rule_operator.ge,
		rule_operator.eq -&gt; {
			return op_context.block_height &gt;= value;
		}
		else -&gt; {
			return true;
		}
	}
}


/****************************************************************************************
 *                                     op_count                                         *
 ****************************************************************************************/
 
 function op_count_variable_initial_value(): gtv {
 	return (1).to_gtv();
 }
 
 function is_op_count_rule_active(rule: gtv): boolean {
 	return true;
 }</string>
                            </entry>
                            <entry key="lib/ft3/account/module.rell">
                                <string>@mount('ft3')
module;

import core: ^.core;

struct auth_descriptor {
    auth_type: text;
    participants: list&lt;byte_array&gt;;
    args: list&lt;gtv&gt;;
    rules: gtv;
}

entity account {
    key id: byte_array;
}

entity account_meta {
    meta_key: text;
    value: byte_array;
    index account, meta_key;
    index meta_key, value;
}

entity account_auth_descriptor {
     descriptor_id: byte_array;
     key account, descriptor_id;
     index descriptor_id;
     auth_type: text;
     args: byte_array;
     rules: byte_array;
}

entity auth_descriptor_participant {
    key account_auth_descriptor, id: byte_array;
}


// rate limiter
entity rl_state {
    key account;
    mutable points: integer;
    mutable last_update: timestamp;
    mutable max_points: integer;
    mutable recovery_time: timestamp;
}

function _add_auth_descriptor (account, auth_descriptor) {
     val descriptor_id = auth_descriptor.hash();
     
     analyze_auth_descriptor_rules(auth_descriptor.rules, 0);
     
     val account_auth_descriptor = create account_auth_descriptor (
        account, descriptor_id,
        auth_descriptor.auth_type,
        args = auth_descriptor.args.to_gtv().to_bytes(),
        rules = auth_descriptor.rules.to_gtv().to_bytes()
     );
     
     for (participant in auth_descriptor.participants) {
        require(is_signer(participant));
        create auth_descriptor_participant(account_auth_descriptor, id = participant);
     }
     
     setup_auth_descriptor_variables(account_auth_descriptor);
}

function _delete_auth_descriptor(auth_descriptor: account_auth_descriptor) {
	delete auth_descriptor_rule_variable @* { auth_descriptor };
	delete auth_descriptor_participant @* { auth_descriptor };
	delete auth_descriptor;
}

function _delete_all_auth_descriptors_exclude(account, auth_descriptor_id: byte_array) {
	delete (adrv: auth_descriptor_rule_variable, ad: account_auth_descriptor) @* {
		ad.account == account, ad.descriptor_id != auth_descriptor_id, adrv.account_auth_descriptor == ad		
	};
	
	delete (adp: auth_descriptor_participant, ad: account_auth_descriptor) @* {
        ad.account == account and ad.descriptor_id != auth_descriptor_id and adp.account_auth_descriptor == ad
    };

    delete account_auth_descriptor @* {
       .account == account,
       .descriptor_id != auth_descriptor_id
    };
}

function create_account_with_auth (auth_descriptor): byte_array {
     val id = auth_descriptor.hash();
     val acc = create account (id);
     _add_auth_descriptor(
        acc, auth_descriptor
     );
     val max_points = core.my_blockchain_info.rate_limit_max_points;
     val recovery_time = core.my_blockchain_info.rate_limit_recovery_time;
     val points_at_start = core.my_blockchain_info.rate_limit_points_at_account_creation;
     
	create rl_state(acc, .points = points_at_start, .last_update = op_context.last_block_time, max_points, recovery_time);
    
    return id;
}

function auth_and_log(account_id: byte_array, auth_descriptor_id: byte_array, required_flags: list&lt;text&gt;): account {
	val account = account @ { .id == account_id };
	rate_limit(account);
	require_auth(account, auth_descriptor_id, required_flags);
	return account;
}

query is_auth_descriptor_valid(account_id: byte_array, auth_descriptor_id: byte_array) {
    return is_valid(account_auth_descriptor @ {
        .account.id == account_id,
        .descriptor_id == auth_descriptor_id
    });
}

query get_account_auth_descriptors(id: byte_array) {
    return account_auth_descriptor @* {
        .account.id == id
    } (
        id = .descriptor_id,
        type = .auth_type,
        args = .args
    );
}

query get_account_by_id(id: byte_array) {
    return account @? { id } ( .id );
}

query get_account_by_auth_descriptor(auth_descriptor) {
    return account @? { .id == auth_descriptor.hash() } ( .id );
}

query get_accounts_by_participant_id(id: byte_array) {
    return auth_descriptor_participant @* { id } ( .account_auth_descriptor.account.id );
}

query get_accounts_by_auth_descriptor_id(descriptor_id: byte_array) {
    return account_auth_descriptor @* { descriptor_id } ( .account.id );
}
</string>
                            </entry>
                            <entry key="lib/ft3/account/operations/module.rell">
                                <string>@mount('ft3')
module;

import acc: ^^.account;
import core: ^^.core;


operation delete_auth_descriptor(account_id: byte_array, auth_descriptor_id: byte_array, delete_descriptor_id: byte_array) {
    val flags = if (auth_descriptor_id == delete_descriptor_id) list&lt;text&gt;() else ["A"];

    val account = acc.auth_and_log(account_id, auth_descriptor_id, flags);

    acc._delete_auth_descriptor(acc.account_auth_descriptor @ {
        .account == account,
        .descriptor_id == delete_descriptor_id
    });
}

operation delete_all_auth_descriptors_exclude(account_id: byte_array, auth_descriptor_id: byte_array) {
    val account = acc.auth_and_log(account_id, auth_descriptor_id, ["A"]);

	acc._delete_all_auth_descriptors_exclude(account, auth_descriptor_id);
}

operation add_auth_descriptor (account_id: byte_array, auth_id: byte_array, new_desc: acc.auth_descriptor) {
      val account = acc.auth_and_log(account_id, auth_id, ["A"]);
      acc._add_auth_descriptor(account, new_desc);
}
</string>
                            </entry>
                            <entry key="lib/ft3/account/rate_limit.rell">
                                <string>import ^.core;


function rate_limit (account) {
	if(core.my_blockchain_info.rate_limit_active == false ) return;
    val max_counter = core.my_blockchain_info.rate_limit_max_points;
    val recovery_time = core.my_blockchain_info.rate_limit_recovery_time;
    val stat = rl_state@{account} (.points, .last_update);
    val delta = op_context.last_block_time - stat.last_update;
    var got_points = 0;
    var update_time = stat.last_update;

    if (delta &gt; recovery_time)
    {
        got_points = delta / recovery_time;
        update_time = stat.last_update + got_points * recovery_time;
        if (got_points + stat.points &gt; max_counter) {
            got_points = max_counter - stat.points;
            // if user is at maximum reset his 
            // timer
            update_time = op_context.last_block_time;
        }
    }
    
    require(stat.points + got_points &gt; 0);
    
    update rl_state@{account} (
        .points += got_points - 1,
        .last_update = update_time
    );
}


query get_account_rate_limit_last_update(account_id: byte_array) {
	if(core.my_blockchain_info.rate_limit_active == false ) return (points = 0, last_update = 0);
	val t= rl_state@{.account.id == account_id}
	(
		.points, 
		.last_update
	);
	
	return t;
}

query get_last_timestamp(): integer {
	return (block@{.timestamp&gt;0}(@sort_desc .timestamp) limit 1);
}</string>
                            </entry>
                            <entry key="lib/ft3/core/asset.rell">
                                <string>import acc: ^.account;

entity asset {
    id: byte_array;
    key id;
    name;
    issuing_chain_rid: byte_array;
}

entity balance {
    key acc.account, asset;
    mutable amount: integer = 0;
}

function ensure_balance(acc.account, asset): balance {
    val balance = balance @? {asset, account};
    if (balance != null) {
       return balance;
    }
    else return create balance(account, asset, amount = 0);
}

function register_asset (name, issuing_chain_rid: byte_array): asset {
   val id = (name, issuing_chain_rid).hash();
   return create asset (id, name, issuing_chain_rid);
}

function _get_asset_balances(account_id: byte_array): list&lt;(id:byte_array,name:text,amount:integer,chain_id:byte_array)&gt; {
    return balance @* { .account.id == account_id } (
      id = .asset.id,
      name = .asset.name,
      amount = .amount,
      chain_id = .asset.issuing_chain_rid
    );
}

query get_asset_balances(account_id: byte_array) {
    return _get_asset_balances(account_id);
}

query get_asset_balance(account_id: byte_array, asset_id: byte_array) {
    return balance @? {
        .account.id == account_id,
        .asset.id == asset_id
    } (
        id = .asset.id,
        name = .asset.name,
        amount = .amount,
        chain_id = .asset.issuing_chain_rid
    );
}

query get_asset_by_name(name) {
    return asset @* { name } (
        .id,
        .name,
        .issuing_chain_rid
    );
    
}

query get_asset_by_id(asset_id: byte_array) {
	return asset@{
		.id == asset_id
	}(
		id = .id,
		name = .name,
		issuing_chain_rid = .issuing_chain_rid
		
	);
}

query get_all_assets() {
	return asset@*{}(
		id = .id,
		name = .name,
		issuing_chain_rid = .issuing_chain_rid	
	);
}</string>
                            </entry>
                            <entry key="lib/ft3/core/dev_op.rell">
                                <string>module;

import ft3: ^^.core;
import acc: ^^.account;

object dev_state {
   mutable allow_dev_ops: boolean = true;
}

function require_dev() {
    require(dev_state.allow_dev_ops);
}

function dev_give_points_(account: acc.account, amount: integer) {
	require_dev();
	update acc.rl_state@{account}(.points += amount);
}</string>
                            </entry>
                            <entry key="lib/ft3/core/history.rell">
                                <string>import acc: ^.account;

@log entity payment_history_entry {
    index acc.account, asset;
    delta: integer;

    // helps to locate exact position of payment entry in transaction
    op_index: integer;
    is_input: boolean;
    entry_index: integer;
}

query get_payment_history(account_id: byte_array, after_block: integer) {
    return payment_history_entry @* {
        acc.account @ { account_id },
        .transaction.block.block_height &gt; after_block
    } (
        delta = .delta,
        asset = .asset.name,
        asset_id = .asset.id,
        is_input = .is_input,
        timestamp = .transaction.block.timestamp,
        block_height = .transaction.block.block_height,
        entry_index = .entry_index,
        tx_rid = .transaction.tx_rid,
        tx_data = .transaction.tx_data
    );
}
</string>
                            </entry>
                            <entry key="lib/ft3/core/module.rell">
                                <string>@mount('ft3')
module;

struct module_args {
	my_blockchain_name: text;
	my_blockchain_website: text;
	my_blockchain_description: text;
	rate_limit_active: boolean;
	rate_limit_max_points: integer;
    rate_limit_recovery_time: integer;
    rate_limit_points_at_account_creation: integer;    
}</string>
                            </entry>
                            <entry key="lib/ft3/core/my_blockchain_info.rell">
                                <string>
object my_blockchain_info {
    mutable name: text = chain_context.args.my_blockchain_name;
    mutable website: text = chain_context.args.my_blockchain_website;
    mutable description: text = chain_context.args.my_blockchain_description;
    mutable rate_limit_active: boolean = chain_context.args.rate_limit_active;
    mutable rate_limit_max_points: integer = chain_context.args.rate_limit_max_points;
    mutable rate_limit_recovery_time: integer = chain_context.args.rate_limit_recovery_time;
    mutable rate_limit_points_at_account_creation: integer = chain_context.args.rate_limit_points_at_account_creation;
}


//operation update_blockchain(name, website: text, description: text) {
//    blockchain.name = name;
//    blockchain.website = website;
//    blockchain.description = description;
//}

query get_blockchain_info() {
    return (
        name = my_blockchain_info.name,
        website = my_blockchain_info.website,
        description = my_blockchain_info.description,
        rate_limit_active = my_blockchain_info.rate_limit_active,
        rate_limit_max_points = my_blockchain_info.rate_limit_max_points,
        rate_limit_recovery_time = my_blockchain_info.rate_limit_recovery_time,
        rate_limit_points_at_account_creation = chain_context.args.rate_limit_points_at_account_creation
    );
}

</string>
                            </entry>
                            <entry key="lib/ft3/core/operations/transfer.rell">
                                <string>@mount('ft3')
module;

import ft3: ^^;


operation transfer (inputs: list&lt;ft3.xfer_input&gt;, outputs: list&lt;ft3.xfer_output&gt;) {
    ft3._transfer(inputs, outputs);
}</string>
                            </entry>
                            <entry key="lib/ft3/core/transfer.rell">
                                <string>import acc: ^.account;

struct xfer_input {
   account_id: byte_array;
   asset_id: byte_array;
   auth_descriptor_id: byte_array;
   amount: integer;
   extra: map&lt;text, gtv&gt;;
}

struct xfer_output {
   account_id: byte_array;
   asset_id: byte_array;
   amount: integer;
   extra: map&lt;text, gtv&gt;;
}

function deduct_balance (acc.account, asset, d_amount: integer) {
    val b = balance @ { account, asset };
    require( b.amount &gt;= d_amount, "Balance is too low");
    update b (amount -= d_amount);
}

function consume_input (i: xfer_input, idx: integer, assets: map&lt;asset, integer&gt;): payment_history_entry {
      val asset = asset @ { .id == i.asset_id };
      val account = acc.auth_and_log(i.account_id, i.auth_descriptor_id, ["T"]);
      require( i.amount &gt; 0, "Amount should be non 0 positive." );

      deduct_balance(account, asset, i.amount);
      assets[asset] = i.amount + if (asset in assets) assets[asset] else 0;
      return create payment_history_entry (
        account,
        asset,
        .delta = i.amount,
        .op_index = 500, //op_context ???
        .is_input = true,
        .entry_index = idx
      );
}

function process_transfer_output (o: xfer_output, idx: integer, available_assets: map&lt;asset, integer&gt;): payment_history_entry {
      if (o.extra.contains("reg_auth_desc")) {
          val auth_desc = acc.auth_descriptor.from_gtv(o.extra["reg_auth_desc"]);
          require(o.account_id
           == acc.create_account_with_auth(auth_desc));
      }

      val target_account = acc.account @ { .id == o.account_id };
      val asset = asset @ { .id == o.asset_id };
      require(o.amount &gt; 0, "You cannot tx output negative numbers");
      require( available_assets[asset] &gt;= o.amount );
      available_assets[asset] -= o.amount;
      require(available_assets[asset] &gt;= 0);
      val balance = ensure_balance(target_account, asset);
      balance.amount += o.amount;

      return create payment_history_entry (
        .account = target_account,
        asset,
        .delta = o.amount,

        .op_index = 500, // something from op_context,
        .is_input = false,
        .entry_index = idx
      );
}

function _transfer (inputs: list&lt;xfer_input&gt;, outputs: list&lt;xfer_output&gt;) {
   val sum_inputs = map&lt;asset, integer&gt;();
   var idx = 0;
   for (i in inputs) {
      consume_input(i, idx, sum_inputs);
      idx += 1;
   }

   idx = 0;
   for (o in outputs) {
      process_transfer_output(o, idx, sum_inputs);
      idx += 1;
   }
}
</string>
                            </entry>
                            <entry key="lib/ft3/crosschain/blockchain.rell">
                                <string>import ft3: ^.core;
import acc: ^.account;


entity asset_origin {
    key ft3.asset;
    origin_chain_rid: byte_array;
}

entity linked_chain {
    key chain_rid: byte_array;
}

function blockchain_account_id (blockchain_rid: byte_array): byte_array {
   return ("B", blockchain_rid).hash();
}

function ensure_blockchain_account (blockchain_rid: byte_array): acc.account {
   val blockchain_account_id = blockchain_account_id(blockchain_rid);
   val acc = acc.account @? { .id == blockchain_account_id };
   return if (acc??)  acc
   else create acc.account (id = blockchain_account_id);
}

function get_blockchain_account (blockchain_rid: byte_array): acc.account {
   return acc.account @ { .id == blockchain_account_id(blockchain_rid) };
}


query get_linked_chains() {
    return linked_chain @* {} ( .chain_rid );
}

query is_linked_with_chain(chain_rid: byte_array) {
    return linked_chain @? { chain_rid } != null;
}
</string>
                            </entry>
                            <entry key="lib/ft3/crosschain/module.rell">
                                <string>@mount('ft3.xc')
module;
</string>
                            </entry>
                            <entry key="lib/ft3/crosschain/structures.rell">
                                <string>struct operation_rec {
   name;
   args: list&lt;gtv&gt;;
}

struct transaction_body_rec {
    blockchain_rid: byte_array;
    operations: list&lt;operation_rec&gt;;
    signers: list&lt;gtv&gt;;
}

struct transaction_rec {
   body: transaction_body_rec;
   signatures: list&lt;gtv&gt;;
}

struct transaction_proof {
     tx: virtual&lt;transaction_rec&gt;;
     // block_header: byte_array;
     // merkle_path: virtual&lt;list&lt;byte_array&gt;&gt;;
     // tx_index: integer;
     block_rid: byte_array;
     block_signers: list&lt;byte_array&gt;;
     signatures: list&lt;byte_array&gt;;     
}

function verify_transaction_proof( p: transaction_proof ) {
   // TODO
}</string>
                            </entry>
                            <entry key="lib/ft3/crosschain/transfer.rell">
                                <string>import ft3: ^.core;

struct xc_target {
    account_id: byte_array;
    extra: map&lt;text, gtv&gt;;
}

function add_to_blockchain_balance (blockchain_rid: byte_array, ft3.asset, amount: integer) {
    require( chain_context.blockchain_rid != blockchain_rid ); // cannot add to own account

    val origin_chain_rid = asset_origin @? { asset } .origin_chain_rid;

    if (exists(origin_chain_rid) and (blockchain_rid == origin_chain_rid)) {
       // do nothing. in future we might track origin
    } else {
         val bc_acc = ensure_blockchain_account(blockchain_rid);
         ft3.ensure_balance(bc_acc, asset).amount += amount;
    }
}


struct init_xfer_args {
          source: ft3.xfer_input;
          target: xc_target;
          hops: list&lt;byte_array&gt;;
}

entity applied_transfers { key tx_rid: byte_array; }


</string>
                            </entry>
                            <entry key="lib/ft3/ft3_basic_dev.rell">
                                <string>module;

namespace ft3 {
	import acc: lib.ft3.account;
	import acc_op: lib.ft3.account.operations;
	import core: lib.ft3.ft3_basic_dev;
	import transfer_op: lib.ft3.core.operations.transfer;
//	import lib.ft3.crosschain;
//	import lib.ft3.crosschain.operations;
	
	import lib.ft3.operations.dev_op_account;
	import lib.ft3.operations.dev_op_asset;
	import lib.ft3.operations.dev_op_balance;
	import lib.ft3.operations.dev_op_rate_limit;
}

</string>
                            </entry>
                            <entry key="lib/ft3/operations/dev_op_account.rell">
                                <string>@mount('ft3')
module;

import dev_op: ^^.core.dev_op;
import acc: ^^.account; 


operation dev_register_account (acc.auth_descriptor) {
    dev_op.require_dev();
    acc.create_account_with_auth( auth_descriptor );
}
</string>
                            </entry>
                            <entry key="lib/ft3/operations/dev_op_asset.rell">
                                <string>@mount('ft3')
module;

import dev_op: ^^.core.dev_op;
import ft3: ^^.core;

import xft3: ^^.crosschain; 

operation dev_register_asset (name, issuing_chain_rid: byte_array) {
    dev_op.require_dev();
    ft3.register_asset(name, issuing_chain_rid);
}

operation dev_register_xc_asset (name, issuing_chain_rid: byte_array, origin_chain_rid: byte_array) {
    dev_op.require_dev();   
    val asset = ft3.register_asset(name, issuing_chain_rid);
    create xft3.asset_origin (asset, origin_chain_rid);
}
</string>
                            </entry>
                            <entry key="lib/ft3/operations/dev_op_balance.rell">
                                <string>@mount('ft3')
module;

import dev_op: ^^.core.dev_op;
import ft3: ^^.core;
import acc: ^^.account;


operation dev_give_balance (asset_id: byte_array, account_id: byte_array, amount: integer) {
    dev_op.require_dev();
    require(amount &gt;= 0);
    ft3.ensure_balance( acc.account @ { account_id }, ft3.asset @ { .id == asset_id } ).amount += amount;
}</string>
                            </entry>
                            <entry key="lib/ft3/operations/dev_op_rate_limit.rell">
                                <string>@mount('ft3')
module;

import dev_op: ^^.core.dev_op;
import acc: ^^.account;



/*
 * Can be negative
 */
operation dev_give_points(account_id: byte_array, amount: integer){
	val account = acc.account@{.id == account_id};
	dev_op.dev_give_points_(account, amount);
}

operation dev_free_op(account_id: byte_array) {
	// this operation does not cost points in the rate limit
	val account = acc.account@{.id == account_id};
	dev_op.dev_give_points_(account, 1);
	acc.rate_limit(account);
}</string>
                            </entry>
                            <entry key="main.rell">
                                <string>import lib.ft3.ft3_basic_dev;

// Remove for production
// ---

import user;
import topic;
import notifications;
import channel;
import follow;
import election;
import representative;
import chat;</string>
                            </entry>
                            <entry key="notifications/index.rell">
                                <string>import user;

entity notification {
    key id: text, user.user;
    trigger: text;
    content: text;
    mutable read: boolean;
    index timestamp;
}
</string>
                            </entry>
                            <entry key="notifications/operations.rell">
                                <string>import user;
import user.distrust;

operation create_notifications_for_users(name, descriptor_id: byte_array, id: text, trigger: text, content: text, usernames: set&lt;text&gt;) {
    val opr_user = user.get_verified_user(name, descriptor_id);

    for (username in usernames) {
        val toUser = user.user@?{ .name == username.lower_case() };
        if (toUser != null and distrust.user_distrust@?{ .distruster == toUser, .distrusted == opr_user } == null) {
            create notification(
                id = id,
                toUser,
                trigger = trigger,
                content = content,
                false,
                op_context.last_block_time
            );
        }
    }
}

operation remove_notifications_for_users(name, descriptor_id: byte_array, id: text, usernames: set&lt;text&gt;) {
    val user = user.get_verified_user(name, descriptor_id);

    for (username in usernames) {
        val to_user = user.user@?{ .name == username };
        if (to_user != null) {
            delete notification@?{ id, .user == to_user };
        }
    }
}

operation mark_notifications_since_timestamp_read(name, descriptor_id: byte_array, timestamp) {
    val user = user.get_verified_user(name, descriptor_id);
    update notification@*{ .user == user, .timestamp &gt; timestamp } ( read = true );
}</string>
                            </entry>
                            <entry key="notifications/queries.rell">
                                <string>import user;

query count_unread_user_notifications(name) {
    val user = user.user@{ .name == name };
    return notification@*{ .user == user, .read == false } ( .id );
}

query get_user_notifications_prior_to_timestamp(name, timestamp, page_size: integer) {
    val user = user.user@{ .name == name };
    return notification@*{ .user == user, .timestamp &lt; timestamp } (
        .id,
        .trigger,
        .content,
        .read,
        @sort_desc .timestamp
    ) limit page_size;
}
</string>
                            </entry>
                            <entry key="representative/functions.rell">
                                <string>import user;
import election;

function is_username_representative(name): boolean {
	val user = user.user@?{ .name == name};
	
	if (user == null) {
		return false;
	}
	
	val prev_election = election.get_latest_completed_election_id();
	
	if (prev_election == null) {
		return false;
	}
	
	return representative@?{ .user == user, .representative_election.id == prev_election } != null;
}

function is_user_suspended(rep: user.user, suspendee: user.user, timestamp): boolean {
	return user.user_suspension@?{ 
		.user == suspendee, 
		.suspended_by == rep,
		.suspended_until &gt;= timestamp
	} != null;
} </string>
                            </entry>
                            <entry key="representative/index.rell">
                                <string>import election;
import user;

entity representative {
    key user.user, election.representative_election;
}

entity representative_action {
    key id: byte_array;
    index representative;
    index timestamp;
    action: text;
}

entity representative_distrust {
	key distruster: user.user, representative;
}

import representative.report;
</string>
                            </entry>
                            <entry key="representative/operations.rell">
                                <string>import election;
import topic;
import user;
import util;

operation remove_topic(username: text, descriptor_id: byte_array, topic_id: text) {
    val user = user.get_verified_user(username, descriptor_id);

    val recent_election = election.representative_election@{ .completed == true } ( .id, @sort_desc .timestamp ) limit 1;
    val representative = representative @{ user, .representative_election.id == recent_election.id };

    val the_topic = topic.topic @{ .id == topic_id };
    
    create topic.topic_moderation(representative.user, the_topic);

    create representative_action(
        id = op_context.transaction.tx_rid,
        representative,
        op_context.last_block_time,
        action = "Topic /t/" + the_topic.id + " was removed by @" + user.display_name
    );
}

operation remove_topic_reply(username: text, descriptor_id: byte_array, topic_reply_id: text) {
    val user = user.get_verified_user(username, descriptor_id);

    val recent_election_id = require(election.get_latest_completed_election_id(), "No election has been held yet");
    val representative = representative @{ user, .representative_election.id == recent_election_id };

    val the_reply = topic.topic_reply @{ .id == topic_reply_id };
    
    create topic.topic_reply_moderation(representative.user, the_reply);

    create representative_action(
        id = op_context.transaction.tx_rid,
        representative,
        op_context.last_block_time,
        action = "Reply in topic /t/" + the_reply.topic.id + " was removed by @" + user.display_name
    );
}

operation suspend_user(username: text, descriptor_id: byte_array, user_to_be_suspended: text) {
    val user = user.get_verified_user(username, descriptor_id);

    val recent_election_id = require(election.get_latest_completed_election_id(), "No election has been held yet");
    val representative = representative @{ user, .representative_election.id == recent_election_id };

    val suspendee = user.user@{ .name == user_to_be_suspended };
    
    val action_id = "suspend_user:" + user_to_be_suspended;
	
	require(
		not is_user_suspended(user, suspendee, op_context.last_block_time), 
		"User already suspended"
	);
	
    val updated_times_suspended = user.user_suspension@*{
    	.user == suspendee,
    	.suspended_by == user
    }( .user ).size() + 1;
    
    val one_day_millis = 86400000;
    val days_suspended = updated_times_suspended * updated_times_suspended;
    val suspension_time_millis = days_suspended * one_day_millis;
	val suspended_until = op_context.last_block_time + suspension_time_millis;

	create user.user_suspension(user = suspendee, suspended_by = user, suspended_until);

    var daysString = " days ";
    if (days_suspended == 1) {
        daysString = " day ";
    }

    create representative_action(
        id = op_context.transaction.tx_rid,
        representative,
        op_context.last_block_time,
        action = "@" + suspendee.display_name + " was suspended for " + days_suspended + daysString +  "by @" + user.display_name
    );
}

operation distrust_representative(name, descriptor_id: byte_array, distrusted: name) {
	val user = user.get_verified_user(name, descriptor_id);
	
	val recent_election_id = require(election.get_latest_completed_election_id(), "No election has been held yet");
	
	require(is_eligible_to_distrust(user, recent_election_id), "User is not eligible to distrust");
	
    val representative = representative @{ 
    	.user.name == distrusted.lower_case(), 
    	.representative_election.id == recent_election_id
    };
    
    val required_votes = election.temp_votes_counter@{
    	.representative_election_candidate.representative_election.id == recent_election_id
    } ( @sort_desc .votes ) limit 1;
    
    val distrusts = representative_distrust@*{ 
    	representative
    }( .distruster ).size();
    
    if (distrusts &gt;= 10 and distrusts &gt; required_votes) {
    	delete representative;
    } else {
    	create representative_distrust(user, representative);
    }
}

function is_eligible_to_distrust(user.user, prev_election_id: integer): boolean {	
	val recent_election_start = election.election_block_details@{
		.representative_election.id == prev_election_id
	} ( .started_height );
	
	if (user.registered &gt; recent_election_start) {
		log("User must have registered before the previous election started");
		return false;
	}
	
	val previous_election_completed = (election: election.representative_election, details: election.election_block_details)@?{
		election.id != prev_election_id,
		election == details.representative_election,
		election.completed == true
	} ( 
		details.finished_height,
		@omit @sort_desc election.timestamp
	) limit 1;
	
	if (previous_election_completed == null) {
		return true;
	}
	
	val number_of_topics = topic.topic@*{ 
		.author == user,
		.last_modified &gt; previous_election_completed,
		.last_modified &lt; recent_election_start
	}( .id ).size();
	
	val number_of_replies = topic.topic_reply@*{
		.author == user,
		.timestamp &gt; previous_election_completed,
		.timestamp &lt; recent_election_start
	}( .id ).size();
	
	return number_of_topics + number_of_replies &gt;= 5;
}</string>
                            </entry>
                            <entry key="representative/queries.rell">
                                <string>import election;
import user;

query get_representatives(): list&lt;name&gt; {
    val election = election.representative_election@?{ .completed == true } ( .id, @sort_desc .timestamp ) limit 1;

    if (election == null) {
        return list&lt;name&gt;();
    }

    return representative@*{
        .representative_election.id == election.id
    } ( .user.name );
}

query get_all_representative_actions(timestamp, page_size: integer) {
    return representative_action@*{
        .timestamp &lt; timestamp
    } (
        .id,
        representative = .representative.user.name,
        @sort_desc .timestamp,
        .action
    ) limit page_size;
}

query get_number_of_times_representative(name) {
    return representative@*{ .user.name == name } ( .representative_election.id ).size();
}

query is_user_suspended_by_me(username: name, user_to_be_suspended: name, timestamp) {
	val user = user.user@{ .name == username.lower_case() };
	val suspendee = user.user@{ .name == user_to_be_suspended.lower_case() };
	return is_user_suspended(user, suspendee, timestamp);
}</string>
                            </entry>
                            <entry key="representative/report/index.rell">
                                <string>import user;

entity representative_report {
    key id: text;
    index timestamp;
    text;
}
</string>
                            </entry>
                            <entry key="representative/report/operations.rell">
                                <string>import election;
import user;
import representative;
import util;

operation create_representative_report(username: text, descriptor_id: byte_array, id: text, text) {
    val user = user.get_and_charge_verified_user(username, descriptor_id);
    create representative_report(id = id, op_context.last_block_time, text = text);
}
</string>
                            </entry>
                            <entry key="representative/report/queries.rell">
                                <string>query get_unhandled_representative_reports(timestamp) {
    return representative_report@*{
    	.timestamp &gt; timestamp
    } ( 
    	.id, 
    	@sort_desc .timestamp, 
    	.text
    ) limit 25;
}</string>
                            </entry>
                            <entry key="topic/functions.rell">
                                <string>import util;

function find_topic_by_id(id: text): topic {
    return topic@{ .id == id };
}

function require_mutable(post_timestamp: timestamp, op_timestamp: timestamp, action: text) {
	val fiveMinutesInMillis = 300000;
    require(
    	op_timestamp &lt; post_timestamp + fiveMinutesInMillis,
    	util.app_error(util.error_type.TOPIC_IMMUTABLE, action)
    );
}

function get_latest_poster_in_topic(id: text, topic_author: name): text {
	val latest_reply = topic_reply@?{ .topic.id == id} (
		@sort_desc .timestamp,
		.author
	) limit 1;
	
	if (latest_reply != null) {
		return latest_reply.author.display_name;
	} else {
		return topic_author;
	}
}</string>
                            </entry>
                            <entry key="topic/index.rell">
                                <string>import user;

entity topic {
    key id: text;
    index author: user.user;
    timestamp;
    mutable last_modified: timestamp;
    index last_modified;
    title: name;
    mutable message: text;
}

entity topic_moderation {
	key user.user, topic;
}

entity topic_reply {
    key id: text;
    index topic;
    index author: user.user;
    index timestamp;
    is_sub_reply: boolean = false;
    index is_sub_reply;
    mutable message: text;
}

entity topic_reply_moderation {
	key user.user, topic_reply;
}

entity sub_reply {
    key parent_reply: topic_reply, child_reply: topic_reply;
}

struct ext_topic {
	id: text;
	author: text;
	title: text;
	message: text;
	timestamp;
	last_modified: timestamp;
	latest_poster: name;
	moderated_by: list&lt;name&gt;;
}

struct ext_topic_reply {
	id: text;
	author: text;
	message: text;
	is_sub_reply: boolean;
	timestamp;
	moderated_by: list&lt;name&gt;;
}

import topic.rating;
import topic.subscription;
</string>
                            </entry>
                            <entry key="topic/operations.rell">
                                <string>import channel;
import topic.rating;
import user;
import topic.subscription;
import topic.poll;

operation create_topic(id: text, descriptor_id: byte_array, username: text, channel_key: name, channel_name: name, title: name, message: text) {
    val author = user.get_and_charge_verified_user(username, descriptor_id);

    val topic = create topic(
        id = id,
        author,
        timestamp = op_context.last_block_time,
        last_modified = op_context.last_block_time,
        title = title,
        message = message
    );

    create channel.channel(name = channel_key.lower_case(), topic, op_context.last_block_time, display_name = channel_name);
    create rating.tmp_topic_rating (topic, 0);
        
    for (suspension in user.user_suspension@*{ .user == author, .suspended_until &gt; op_context.last_block_time }) {
    	create topic_moderation(suspension.suspended_by, topic);
    }
}

operation modify_topic(id: text, descriptor_id: byte_array, username: text, text) {
    val author = user.get_verified_user(username, descriptor_id);

    val topic = topic@{ .id == id, .author == author };
    require_mutable(topic.timestamp, op_context.last_block_time, "Modify topic");

    update topic ( message = text );
}

operation delete_topic(id: text, descriptor_id: byte_array, username: text) {
    val author = user.get_verified_user(username, descriptor_id);

    val topic = topic@{ .id == id, .author == author };
    require_mutable(topic.timestamp, op_context.last_block_time, "Delete topic");
    delete channel.channel@{ topic };
    delete rating.tmp_topic_rating@{ topic };
    delete subscription.subscription@?{ topic };
    
    val opt_poll = poll.poll@?{ topic };
    if (opt_poll != null) {
    	delete poll.poll_option@*{ .poll == opt_poll };
    	delete poll.poll_vote@*{ .poll == opt_poll };
    }
    
	delete topic;
}

operation create_reply(topic_id: text, descriptor_id: byte_array, id: text, username: text, message: text) {
    val author = user.get_and_charge_verified_user(username, descriptor_id);
    val topic = find_topic_by_id(topic_id);

    val reply = create topic_reply(
        id = id,
        topic,
        author,
        timestamp = op_context.last_block_time,
        message = message
    );
    
    for (suspension in user.user_suspension@*{ .user == author, .suspended_until &gt; op_context.last_block_time }) {
    	create topic_reply_moderation(suspension.suspended_by, reply);
    }

     update topic ( last_modified = op_context.last_block_time);
}

operation modify_reply(id: text, descriptor_id: byte_array, username: text, text) {
    val author = user.get_verified_user(username, descriptor_id);

    val reply = topic_reply@{ .id == id, .author == author };
    require_mutable(reply.timestamp, op_context.last_block_time, "Modify reply");

    update reply ( message = text );
}

operation delete_reply(id: text, descriptor_id: byte_array, username: text) {
	val author = user.get_verified_user(username, descriptor_id);
	val reply = topic_reply@{ id, author };
	require_mutable(reply.timestamp, op_context.last_block_time, "Delete reply");
	
	delete sub_reply@?{ .child_reply == reply };
	delete reply;
}

operation create_sub_reply(topic_id: text, descriptor_id: byte_array, parent_reply_id: text, id: text, username: text, message: text) {
    val author = user.get_verified_user(username, descriptor_id);
    val topic = find_topic_by_id(topic_id);

    val topic_reply = create topic_reply(
        id = id,
        topic,
        author,
        timestamp = op_context.last_block_time,
        is_sub_reply = true,
        message = message	
    );
    
    for (suspension in user.user_suspension@*{ .user == author, .suspended_until &gt; op_context.last_block_time }) {
    	create topic_reply_moderation(suspension.suspended_by, topic_reply);
    }

    create sub_reply(
        parent_reply = topic_reply@{ .id == parent_reply_id },
        child_reply = topic_reply
    );

    update topic ( last_modified = op_context.last_block_time);
}</string>
                            </entry>
                            <entry key="topic/poll/index.rell">
                                <string>import topic;
import user;

entity poll {
	key topic.topic;
	text;
}

entity poll_option {
	key poll, text;
	mutable votes: integer;
}

entity poll_vote {
	key poll, user.user;
	poll_option;
}

struct poll_record {
	question: text;
	options: list&lt;option_record&gt;;
}

struct option_record {
	option: text;
	votes: integer;
}</string>
                            </entry>
                            <entry key="topic/poll/operations.rell">
                                <string>import user;
import topic;

operation create_poll(id: text, descriptor_id: byte_array, 
	username: text, question: text, options: list&lt;text&gt;
) {
	val author = user.get_verified_user(username, descriptor_id);
	val topic = topic.topic@{ .id == id, author };
	
	val poll = create poll(topic, question);
	
	for (option in options) {
		create poll_option(poll, option, 0);
	}
}

operation vote_for_poll_option(id: text, descriptor_id: byte_array, username: text, option: text) {
	val user = user.get_verified_user(username, descriptor_id);
	
	val poll_opt = poll_option@{ .poll.topic.id == id, .text == option };

	create poll_vote(poll_opt.poll, user, poll_opt);
	update poll_opt ( .votes+1 );
}</string>
                            </entry>
                            <entry key="topic/poll/queries.rell">
                                <string>query get_poll(topic_id: text): poll_record? {
	val poll = poll@?{ .topic.id == topic_id };
	
	if (poll == null) {
		return null;
	}
	
	val options = list&lt;option_record&gt;();
	for (opt in poll_option@*{ .poll == poll }) {
		options.add(option_record(opt.text, opt.votes));
	}
	
	return poll_record(poll.text, options);
}

query get_poll_vote(topic_id: text, username: text): text? {
	val vote = poll_vote@?{ 
		.poll.topic.id == topic_id, 
		.user.name == username.lower_case()
	};
	
	if (vote == null) return null;
	return vote.poll_option.text;
}</string>
                            </entry>
                            <entry key="topic/queries.rell">
                                <string>import channel;
import follow;
import topic.rating;
import user;
import representative;

query get_topics_after_timestamp(timestamp, page_size: integer) {
    val topics = topic@*{ .last_modified &gt; timestamp } (
        .id,
        author=.author.display_name,
        .title,
        .message,
        @sort_desc .last_modified,
        .timestamp
    ) limit page_size;
    
    val ext_topics = list&lt;ext_topic&gt;();
    
    for (topic in topics) {
    	val moderated_by = topic_moderation@*{ .topic.id == topic.id } ( .user.name );
    	val ext_topic = ext_topic (
			id = topic.id,
			author = topic.author,
			title = topic.title,
			message = topic.message,
			timestamp = topic.timestamp,
			last_modified = topic.last_modified,
			latest_poster = get_latest_poster_in_topic(topic.id, topic.author),
			moderated_by = moderated_by
		);
    	ext_topics.add(ext_topic);
    }
    
    return ext_topics;
}

query get_topics_prior_to_timestamp(timestamp, page_size: integer): list&lt;ext_topic&gt; {
    val topics = topic@*{ .last_modified &lt; timestamp }(
        .id,
        author = .author.display_name,
        .title,
        .message,
        @sort_desc .last_modified,
        .timestamp
    ) limit page_size;
        
    val ext_topics = list&lt;ext_topic&gt;();
    for (topic in topics) {
  	   	val moderated_by = topic_moderation@*{ .topic.id == topic.id } ( .user.name );
    	val ext_topic = ext_topic (
			id = topic.id,
			author = topic.author,
			title = topic.title,
			message = topic.message,
			timestamp = topic.timestamp,
			last_modified = topic.last_modified,
			latest_poster = get_latest_poster_in_topic(topic.id, topic.author),
			moderated_by = moderated_by
		);
    	ext_topics.add(ext_topic);
    }
    
    return ext_topics;
}

query get_topic_replies_prior_to_timestamp(username: name, topic_id: text, timestamp, page_size: integer) {	
    val replies = topic_reply@*{
        topic@{ .id == topic_id },
        .timestamp &lt; timestamp,
        .is_sub_reply == false
    }(
        .id,
        topic_id = .topic.id,
        author= .author.display_name,
        .message,
        .is_sub_reply,
        @sort_desc .timestamp
    ) limit page_size;
    
    val ext_replies = list&lt;ext_topic_reply&gt;();
    for (reply in replies) {
    	val moderated_by = topic_reply_moderation @*{ .topic_reply.id == reply.id } ( .user.name );
    	val ext_reply = ext_topic_reply (
    		id = reply.id,
    		author = reply.author,
    		message = reply.message,
    		is_sub_reply = reply.is_sub_reply,
    		timestamp = reply.timestamp,
    		moderated_by = moderated_by
    	);
    	ext_replies.add(ext_reply);
    }
    
    return ext_replies;
}

query count_topic_replies(topic_id: text) {
	return topic_reply@*{ .topic.id == topic_id }( .id ).size();
}

query get_topic_replies_after_timestamp(username: name, topic_id: text, timestamp, page_size: integer) {	
	val replies = topic_reply@*{
        topic@{ .id == topic_id },
        .timestamp &gt; timestamp,
        .is_sub_reply == false
    }(
        .id,
        topic_id = .topic.id,
        author= .author.display_name,
        .message,
        .is_sub_reply,
        @sort_desc .timestamp
    ) limit page_size;
			
    val ext_replies = list&lt;ext_topic_reply&gt;();
    for (reply in replies) {
    	val moderated_by = topic_reply_moderation @*{ .topic_reply.id == reply.id } ( .user.name );
    	val ext_reply = ext_topic_reply (
    		id = reply.id,
    		author = reply.author,
    		message = reply.message,
    		is_sub_reply = reply.is_sub_reply,
    		timestamp = reply.timestamp,
    		moderated_by = moderated_by
    	);
    	ext_replies.add(ext_reply);
    }
    
    return ext_replies;
}

query get_topic_replies_by_user_prior_to_timestamp(name, timestamp, page_size: integer) {
    return topic_reply@*{ .author.name == name, .timestamp &lt; timestamp } (
        .id,
        topic_id = .topic.id,
        author=.author.display_name,
        .message,
        .is_sub_reply,
        @sort_desc .timestamp
    ) limit page_size;
}

query count_topics_by_user(name): integer {
    return topic@*{ .author.name == name }( .id ).size();
}

query count_replies_by_user(name): integer {
    return topic_reply@*{ .author.name == name }( .id ).size();
}

query get_sub_replies(username: name, parent_reply_id: text) {	
    val replies = sub_reply@*{ .parent_reply.id == parent_reply_id } (
        id= .child_reply.id,
        author= .child_reply.author.display_name,
        message= .child_reply.message,
        is_sub_reply= .child_reply.is_sub_reply,
        @sort timestamp= .child_reply.timestamp
    );
   
   val ext_replies = list&lt;ext_topic_reply&gt;();
    for (reply in replies) {
    	val moderated_by = topic_reply_moderation @*{ .topic_reply.id == reply.id } ( .user.name );
    	val ext_reply = ext_topic_reply (
    		id = reply.id,
    		author = reply.author,
    		message = reply.message,
    		is_sub_reply = reply.is_sub_reply,
    		timestamp = reply.timestamp,
    		moderated_by = moderated_by
    	);
    	ext_replies.add(ext_reply);
    }
    
    return ext_replies;
}

query get_topics_by_user_id_prior_to_timestamp(name, timestamp, page_size: integer) {
    val topics = topic@*{
        user.user@{ .name == name },
        .last_modified &lt; timestamp
    }(
        .id,
        author= .author.display_name,
        .title,
        .message,
        @sort_desc .last_modified,
        .timestamp
    ) limit page_size;
    
    val ext_topics = list&lt;ext_topic&gt;();
    for (topic in topics) {
    	val moderated_by = topic_moderation@*{ .topic.id == topic.id } ( .user.name );
    	val ext_topic = ext_topic (
			id = topic.id,
			author = topic.author,
			title = topic.title,
			message = topic.message,
			timestamp = topic.timestamp,
			last_modified = topic.last_modified,
			latest_poster = get_latest_poster_in_topic(topic.id, topic.author),
			moderated_by = moderated_by
		);
    	ext_topics.add(ext_topic);
    }
    
    return ext_topics;
}

query get_topics_from_follows_after_timestamp(name, timestamp, page_size: integer) {
    val topics = (topic, follow.follow)@*{
            follow.follower.name == name.lower_case(),
            follow.follows == topic.author,
            topic.last_modified &gt; timestamp
    }(
        topic.id,
        author=topic.author.display_name,
        topic.title,
        topic.message,
        @sort_desc topic.last_modified,
        topic.timestamp
    ) limit page_size;
    
    val ext_topics = list&lt;ext_topic&gt;();
    for (topic in topics) {
    	val moderated_by = topic_moderation@*{ .topic.id == topic.id } ( .user.name );
    	val ext_topic = ext_topic (
			id = topic.id,
			author = topic.author,
			title = topic.title,
			message = topic.message,
			timestamp = topic.timestamp,
			last_modified = topic.last_modified,
			latest_poster = get_latest_poster_in_topic(topic.id, topic.author),
			moderated_by = moderated_by
		);
    	ext_topics.add(ext_topic);
    }
    
    return ext_topics;
}

query get_topics_from_follows_prior_to_timestamp(name, timestamp, page_size: integer) {
    val topics = (topic, follow.follow) @* {
        follow.follower.name == name.lower_case(),
        follow.follows == topic.author,
        topic.last_modified &lt; timestamp
    }(
        topic.id,
        author = topic.author.display_name,
        topic.title,
        topic.message,
        @sort_desc topic.last_modified,
        topic.timestamp
    ) limit page_size;
    
    val ext_topics = list&lt;ext_topic&gt;();
    for (topic in topics) {
    	val moderated_by = topic_moderation@*{ .topic.id == topic.id } ( .user.name );
    	val ext_topic = ext_topic (
			id = topic.id,
			author = topic.author,
			title = topic.title,
			message = topic.message,
			timestamp = topic.timestamp,
			last_modified = topic.last_modified,
			latest_poster = get_latest_poster_in_topic(topic.id, topic.author),
			moderated_by = moderated_by
		);
    	ext_topics.add(ext_topic);
    }
    
    return ext_topics;
}

query get_topic_by_id(username: name, id: text) {
    val topic = topic@{ .id == id }(
        .id,
        author = .author.display_name,
        .title,
        .message,
        @sort_desc .last_modified,
        .timestamp
    );
    
    val moderated_by = topic_moderation@*{ .topic.id == topic.id } ( .user.name );
	return ext_topic (
		id = topic.id,
		author = topic.author,
		title = topic.title,
		message = topic.message,
		timestamp = topic.timestamp,
		last_modified = topic.last_modified,
		latest_poster = get_latest_poster_in_topic(topic.id, topic.author),
		moderated_by = moderated_by
	);
}

query get_all_topics_by_stars_since_timestamp(timestamp, page_size: integer) {
    val topics = rating.tmp_topic_rating@*{
        .topic.last_modified &gt; timestamp
    } (
        @sort_desc .stars,
        id = .topic.id,
        author=.topic.author.display_name,
        title=.topic.title,
        message=.topic.message,
        last_modified=.topic.last_modified,
        timestamp=.topic.timestamp
    ) limit page_size;
    
    val ext_topics = list&lt;ext_topic&gt;();
    for (topic in topics) {
    	val moderated_by = topic_moderation@*{ .topic.id == topic.id } ( .user.name );
    	val ext_topic = ext_topic (
			id = topic.id,
			author = topic.author,
			title = topic.title,
			message = topic.message,
			timestamp = topic.timestamp,
			last_modified = topic.last_modified,
			latest_poster = get_latest_poster_in_topic(topic.id, topic.author),
			moderated_by = moderated_by
		);
    	ext_topics.add(ext_topic);
    }
    
    return ext_topics;
}

query get_topics_by_follows_and_stars_since_timestamp(name, timestamp, page_size: integer) {
    val topics = (rating.tmp_topic_rating, follow.follow) @*{
            follow.follower.name == name,
            tmp_topic_rating.topic.author == follow.follows,
            tmp_topic_rating.topic.last_modified &gt; timestamp
        } (
        @sort_desc tmp_topic_rating.stars,
        id = tmp_topic_rating.topic.id,
        author = tmp_topic_rating.topic.author.display_name,
        title = tmp_topic_rating.topic.title,
        message = tmp_topic_rating.topic.message,
        last_modified = tmp_topic_rating.topic.last_modified,
        timestamp = tmp_topic_rating.topic.timestamp
    ) limit page_size;
    
    val ext_topics = list&lt;ext_topic&gt;();
    for (topic in topics) {
    	val moderated_by = topic_moderation@*{ .topic.id == topic.id } ( .user.name );
    	val ext_topic = ext_topic (
			id = topic.id,
			author = topic.author,
			title = topic.title,
			message = topic.message,
			timestamp = topic.timestamp,
			last_modified = topic.last_modified,
			latest_poster = get_latest_poster_in_topic(topic.id, topic.author),
			moderated_by = moderated_by
		);
    	ext_topics.add(ext_topic);
    }
    
    return ext_topics;
}

query get_topics_by_channel_after_timestamp_sorted_by_popularity(name, timestamp, page_size: integer) {
    val topics = (rating.tmp_topic_rating, channel.channel)@*{
        name == channel.name,
        tmp_topic_rating.topic == channel.topic,
        tmp_topic_rating.topic.last_modified &gt; timestamp
    } (
        @sort_desc .stars,
        id = channel.topic.id,
        author = channel.topic.author.display_name,
        title = channel.topic.title,
        message = channel.topic.message,
        last_modified = channel.topic.last_modified,
        timestamp = channel.topic.timestamp
    ) limit page_size;
    
    val ext_topics = list&lt;ext_topic&gt;();
    for (topic in topics) {
    	val moderated_by = topic_moderation@*{ .topic.id == topic.id } ( .user.name );
    	val ext_topic = ext_topic (
			id = topic.id,
			author = topic.author,
			title = topic.title,
			message = topic.message,
			timestamp = topic.timestamp,
			last_modified = topic.last_modified,
			latest_poster = get_latest_poster_in_topic(topic.id, topic.author),
			moderated_by = moderated_by
		);
    	ext_topics.add(ext_topic);
    }
    
    return ext_topics;
}

query get_topics_by_followed_channels_after_timestamp_sorted_by_popularity(name, timestamp, page_size: integer) {
    val topics = (rating.tmp_topic_rating, channel.channel_following, channel.channel)@*{
        channel_following.user == user.user@{ name },
        channel_following.name == channel.name,
        tmp_topic_rating.topic == channel.topic,
        tmp_topic_rating.topic.last_modified &gt; timestamp
    } (
        @sort_desc .stars,
        id = channel.topic.id,
        author = channel.topic.author.display_name,
        title = channel.topic.title,
        message = channel.topic.message,
        last_modified = channel.topic.last_modified,
        timestamp = channel.topic.timestamp
    ) limit page_size;
    
    val ext_topics = list&lt;ext_topic&gt;();
    for (topic in topics) {
    	val moderated_by = topic_moderation@*{ .topic.id == topic.id } ( .user.name );
    	val ext_topic = ext_topic (
			id = topic.id,
			author = topic.author,
			title = topic.title,
			message = topic.message,
			timestamp = topic.timestamp,
			last_modified = topic.last_modified,
			latest_poster = get_latest_poster_in_topic(topic.id, topic.author),
			moderated_by = moderated_by
		);
    	ext_topics.add(ext_topic);
    }
    
    return ext_topics;
}</string>
                            </entry>
                            <entry key="topic/rating/index.rell">
                                <string>import user;
import topic;

entity topic_star_rating {
    key topic.topic, user.user;
}

// To be deleted when GROUP BY and COUNT is supported, then will use topic_star_rating instead
entity tmp_topic_rating {
    key topic.topic;
    mutable stars: integer;
    index stars;
}

entity reply_star_rating {
    key topic.topic_reply, user.user;
}
</string>
                            </entry>
                            <entry key="topic/rating/operations.rell">
                                <string>import user;
import topic;

operation give_topic_star_rating(username: text, descriptor_id: byte_array, id: text, unique_id: text) {
    val user = user.get_verified_user(username, descriptor_id);
    create topic_star_rating(topic.topic@{ .id == id }, user);

    val topicRating = tmp_topic_rating@{ topic.topic@{ .id == id }};
    update topicRating ( stars = topicRating.stars + 1 );
}

operation remove_topic_star_rating(username: text, descriptor_id: byte_array, id: text, unique_id: text) {
    val user = user.get_verified_user(username, descriptor_id);
    delete topic_star_rating@{ topic.topic@{ .id == id }, user };

    val topicRating = tmp_topic_rating@{ topic.topic@{ .id == id }};
    update topicRating ( stars = topicRating.stars - 1 );
}

operation give_reply_star_rating(username: text, descriptor_id: byte_array, id: text, unique_id: text) {
    val user = user.get_verified_user(username, descriptor_id);
    create reply_star_rating(topic.topic_reply@{ .id == id }, user);
}

operation remove_reply_star_rating(username: text, descriptor_id: byte_array, id: text, unique_id: text) {
    val user = user.get_verified_user(username, descriptor_id);
    delete reply_star_rating@{ topic.topic_reply@{ .id == id }, user };
}</string>
                            </entry>
                            <entry key="topic/rating/queries.rell">
                                <string>import topic;

query get_star_rating_for_topic(id: text) {
    return topic_star_rating@*{ topic.topic@{ .id == id }} ( .user.name );
}

query get_star_rating_for_reply(id: text) {
    return reply_star_rating@*{ topic.topic_reply@{ .id == id }} ( .user.name );
}

query count_user_topic_star_rating(name): integer {
    return topic_star_rating@*{ .topic.author.name == name } ( .topic, .user ).size();
}

query count_user_reply_star_rating(name): integer {
    return reply_star_rating@*{ .topic_reply.author.name == name } ( .topic_reply, .user ).size();
}</string>
                            </entry>
                            <entry key="topic/subscription/index.rell">
                                <string>import user;
import topic;

entity subscription {
    key topic.topic, user.user;
}
</string>
                            </entry>
                            <entry key="topic/subscription/operations.rell">
                                <string>import user;
import topic;

operation subscribe_to_topic(username: text, descriptor_id: byte_array, id: text, unique_id: text) {
    val user = user.get_verified_user(username, descriptor_id);
    create subscription(topic.topic@{ .id == id }, user);
}

operation unsubscribe_from_topic(username: text, descriptor_id: byte_array, id: text, unique_id: text) {
    val user = user.get_verified_user(username, descriptor_id);
    delete subscription@{ topic.topic@{ .id == id }, user };
}</string>
                            </entry>
                            <entry key="topic/subscription/queries.rell">
                                <string>import topic;

query get_subscribers_for_topic(id: text) {
    return subscription@*{ topic.topic@{ .id == id }} ( .user.name );
}</string>
                            </entry>
                            <entry key="user/distrust/index.rell">
                                <string>import user;

entity user_distrust {
    key distruster: user.user, distrusted: user.user;
}</string>
                            </entry>
                            <entry key="user/distrust/operations.rell">
                                <string>import user;

operation toggle_distrust(username: name, descriptor_id: byte_array, name, muted: boolean) {
    val user = user.get_and_charge_verified_user(username, descriptor_id);

    if (muted) {
        create user_distrust(distruster = user, distrusted = user.user@{ .name == name });
    } else {
        delete user_distrust@{ .distruster == user, .distrusted == user.user@{ .name == name }};
    }
}
</string>
                            </entry>
                            <entry key="user/distrust/queries.rell">
                                <string>query get_distrusted_users(name) {
    return user_distrust@*{ .distruster.name == name.lower_case() } ( .distrusted.name );
}

query times_user_was_distrusted(name): integer {
	return user_distrust@*{ .distrusted.name == name } ( .distruster ).size();
}

query times_user_distrusted_someone(name): integer {
	return user_distrust@*{ .distruster.name == name } ( .distrusted ).size();
}</string>
                            </entry>
                            <entry key="user/functions.rell">
                                <string>import ft3_acc: lib.ft3.account;
import util;

function get_verified_user(name, descriptor_id: byte_array): user {
    val user = user@{ .name == name.lower_case() };
    ft3_acc.require_auth(user.account, descriptor_id, list&lt;text&gt;());
    return user;
}

function get_and_charge_verified_user(name, descriptor_id: byte_array): user {
	val user = get_verified_user(name, descriptor_id);
	ft3_acc.rate_limit(user.account);
	return user;
}</string>
                            </entry>
                            <entry key="user/index.rell">
                                <string>import ft3_acc: lib.ft3.account;

entity user {
    key name;
    index ft3_acc.account;
    display_name: name;
    registered: integer = 0;
}

entity user_suspension {
	index user;
	index suspended_by: user;
	index suspended_until: timestamp;
}

import user.settings;
import user.distrust;
</string>
                            </entry>
                            <entry key="user/operations.rell">
                                <string>import ft3_acc: lib.ft3.account;

import user.settings;

operation register_user(name, account_id: byte_array) {
    val account = ft3_acc.account @ { account_id };

    val user = create user(name = name.lower_case(), display_name = name, account, op_context.block_height);
    
    create settings.user_settings(user, avatar = "" , description = "");
}
</string>
                            </entry>
                            <entry key="user/queries.rell">
                                <string>import ft3_acc: lib.ft3.account;

query get_user(name) {
    return user@?{ .name == name.lower_case() } ( name = .display_name );
}

query get_account_id(name) {
    return user@?{ .name == name.lower_case() } ( .account.id );
}

query get_registered_at(name) {
	return user@{ .name == name.lower_case() } ( .registered );
}

query username_by_account_id(id: byte_array): name? {
	val account = ft3_acc.account@? { id };
	if (account != null) {
		return user@?{ .account == account } ( .display_name );
	}
	
	return null;
}</string>
                            </entry>
                            <entry key="user/settings/index.rell">
                                <string>import user;

entity user_settings {
    key user.user;
    mutable avatar: text;
    mutable description: text;
}
</string>
                            </entry>
                            <entry key="user/settings/operations.rell">
                                <string>import user;

operation create_user_settings(name, descriptor_id: byte_array, avatar: text, description: text) {
    val user = user.get_verified_user(name, descriptor_id);
    create user_settings(user, avatar = avatar, description = description);
}

operation update_user_settings(name, descriptor_id: byte_array, avatar: text, description: text) {
    val user = user.get_verified_user(name, descriptor_id);
    update user_settings@{ .user == user }( avatar = avatar, description = description );
}
</string>
                            </entry>
                            <entry key="user/settings/queries.rell">
                                <string>import user;

query get_user_settings(name) {
    return user_settings@?{ user.user@{ .name == name }} ( .avatar, .description );
}
</string>
                            </entry>
                            <entry key="util/log.rell">
                                <string>enum error_type {
	USER_UNAUTHORIZED,
	USER_SUSPENDED,
	TOPIC_IMMUTABLE,
	REPRESENTATIVE_ALREADY_SUSPENDED,
	ILLEGAL_ACTION,
	EXPECTED_ERROR
}

function app_error(error_type, action: text): text {
	val msg = when(error_type) {
		USER_UNAUTHORIZED -&gt; message_with_code("CERR_10", "Requester was unauthorized", action);
		USER_SUSPENDED -&gt; message_with_code("CERR_11", "Requester was suspended", action);
		TOPIC_IMMUTABLE -&gt; message_with_code("CERR_20", "Topic is no longer mutable", action);
		REPRESENTATIVE_ALREADY_SUSPENDED -&gt; message_with_code("CERR_30", "User was already suspended", action);
		ILLEGAL_ACTION -&gt; message_with_code("CERR_40", "The attempted action was illegal", action);
		EXPECTED_ERROR -&gt; message_with_code("CERR_50", "Expected error", action);
	};
	
	log(msg);
	return msg;
}

function message_with_code(code: text, message: text, action: text): text {
	return '{"code":"' + code + '","message":"' + message + '","action":"' + action + '"}';
}</string>
                            </entry>
                        </dict>
                    </entry>
                </dict>
            </entry>
        </dict>
    </entry>
    <entry key="signers">
        <array>
            <bytea>0350FE40766BC0CE8D08B3F5B810E49A8352FDD458606BD5FAFE5ACDCDC8FF3F57</bytea>
        </array>
    </entry>
</dict>