Add Potlock contract

Cargo.toml

@@ -69,6 +69,8 @@ members = [
   "contracts/paymaster/meta",
   "contracts/ping-pong-egld",
   "contracts/ping-pong-egld/meta",
+  "contracts/potlock",
+  "contracts/potlock/meta",
   "contracts/proxy-deployer",
   "contracts/proxy-deployer/meta",
   "contracts/proxy-pause",

contracts/potlock/Cargo.toml

@@ -0,0 +1,22 @@
+[package]
+name = "potlock"
+version = "0.0.0"
+authors = ["you"]
+edition = "2021"
+publish = false
+readme = "README.md"
+
+[lib]
+path = "src/potlock.rs"
+
+[dependencies.multiversx-sc]
+version = "0.47.2"
+
+[dependencies.multiversx-sc-modules]
+version = "=0.47.2"
+
+[dev-dependencies]
+num-bigint = "0.4.2"
+
+[dev-dependencies.multiversx-sc-scenario]
+version = "0.47.2"

contracts/potlock/README.md

@@ -0,0 +1,7 @@
+# Paymaster SC
+
+## Overview
+
+
+
+## Implementation

contracts/potlock/meta/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "potlock-meta"
+version = "0.0.0"
+edition = "2021"
+publish = false
+
+[dependencies.potlock]
+path = ".."
+
+[dependencies.multiversx-sc-meta]
+version = "0.47.2"
+default-features = false

contracts/potlock/meta/src/main.rs

@@ -0,0 +1,3 @@
+fn main() {
+    multiversx_sc_meta::cli_main::<potlock::AbiProvider>();
+}

contracts/potlock/multiversx.json

@@ -0,0 +1,3 @@
+{
+    "language": "rust"
+}

contracts/potlock/scenarios/potlock.scen.json

@@ -0,0 +1,39 @@
+{
+    "name": "empty",
+    "steps": [
+        {
+            "step": "setState",
+            "accounts": {
+                "address:owner": {
+                    "nonce": "1",
+                    "balance": "0"
+                }
+            },
+            "newAddresses": [
+                {
+                    "creatorAddress": "address:owner",
+                    "creatorNonce": "1",
+                    "newAddress": "sc:empty"
+                }
+            ]
+        },
+        {
+            "step": "scDeploy",
+            "id": "deploy",
+            "tx": {
+                "from": "address:owner",
+                "contractCode": "mxsc:../output/potlock.mxsc.json",
+                "arguments": [],
+                "gasLimit": "5,000,000",
+                "gasPrice": "0"
+            },
+            "expect": {
+                "out": [],
+                "status": "",
+                "logs": [],
+                "gas": "*",
+                "refund": "*"
+            }
+        }
+    ]
+}

contracts/potlock/src/potlock.rs

@@ -0,0 +1,28 @@
+#![no_std]
+
+multiversx_sc::imports!();
+multiversx_sc::derive_imports!();
+pub mod potlock_admin_interactions;
+pub mod potlock_interactions;
+pub mod potlock_setup;
+pub mod potlock_storage;
+
+/// An empty contract. To be used as a template when starting a new contract from scratch.
+#[multiversx_sc::contract]
+pub trait Potlock:
+    potlock_admin_interactions::PotlockAdminInteractions
+    + potlock_interactions::PotlockInteractions
+    + potlock_setup::PotlockSetup
+    + potlock_storage::PotlockStorage
+    + multiversx_sc_modules::only_admin::OnlyAdminModule
+{
+    #[init]
+    fn init(&self, admin: ManagedAddress) {
+        let caller = self.blockchain().get_caller();
+        self.admins().insert(caller);
+        self.admins().insert(admin);
+    }
+
+    #[upgrade]
+    fn upgrade(&self) {}
+}

contracts/potlock/src/potlock_admin_interactions.rs

@@ -0,0 +1,95 @@
+use crate::{
+    potlock_setup,
+    potlock_storage::{self, PotlockId, ProjectId},
+};
+
+multiversx_sc::imports!();
+multiversx_sc::derive_imports!();
+
+pub type ProjectPercentage = MultiValue2<usize, u64>;
+
+#[multiversx_sc::module]
+pub trait PotlockAdminInteractions:
+    potlock_storage::PotlockStorage
+    + multiversx_sc_modules::only_admin::OnlyAdminModule
+    + potlock_setup::PotlockSetup
+{
+    #[only_admin]
+    #[endpoint(acceptPot)]
+    fn accept_pot(&self, potlock_id: PotlockId) {
+        self.require_potlock_exists(potlock_id);
+        let fee_amount = self.fee_amount().get();
+
+        self.fee_amount_accepted_pots()
+            .update(|amount| *amount += fee_amount);
+        self.fee_pot_proposer(potlock_id).clear();
+    }
+
+    #[only_admin]
+    #[endpoint(removePot)]
+    fn remove_pot(&self, potlock_id: PotlockId) {
+        let pot_proposer = self.fee_pot_proposer(potlock_id).get();
+        let fee_pot_payment = EsdtTokenPayment::new(
+            self.fee_token_identifier().get(),
+            0u64,
+            self.fee_amount().get(),
+        );
+
+        self.send()
+            .direct_non_zero_esdt_payment(&pot_proposer, &fee_pot_payment);
+        self.fee_pot_proposer(potlock_id).clear();
+        self.potlocks().clear_entry(potlock_id);
+    }
+
+    #[only_admin]
+    #[endpoint(acceptApplication)]
+    fn accept_application(&self, project: ProjectId) {
+        self.require_project_exists(project);
+        // TODO: Mark project's status as accepted
+    }
+
+    #[only_admin]
+    #[endpoint(rejectDonation)]
+    fn reject_donation(&self, potlock_id: PotlockId, user: ManagedAddress) {
+        self.require_potlock_exists(potlock_id);
+        let opt_fee_pot_payments = self.pot_donations(potlock_id).get(&user);
+
+        require!(opt_fee_pot_payments.is_some(), "No donation for this user");
+        let fee_pot_payments = unsafe { opt_fee_pot_payments.unwrap_unchecked() };
+
+        self.send()
+            .direct_non_zero_esdt_payment(&user, &fee_pot_payments);
+        self.pot_donations(potlock_id).remove(&user);
+    }
+
+    #[only_admin]
+    #[endpoint(distributePotToProjects)]
+    fn distribute_pot_to_projects(
+        &self,
+        potlock_id: PotlockId,
+        project_percentage: MultiValueEncoded<ProjectPercentage>,
+    ) {
+        self.require_potlock_exists(potlock_id);
+        let pot_donations = self.pot_donations(potlock_id);
+
+        for pp in project_percentage {
+            let (project_id, percentage) = pp.into_tuple();
+            let mut output_payments = ManagedVec::new();
+            for (_, donation) in pot_donations.iter() {
+                let project_share_amount = donation.amount * percentage;
+                let project_share = EsdtTokenPayment::new(
+                    donation.token_identifier,
+                    donation.token_nonce,
+                    project_share_amount,
+                );
+                output_payments.push(project_share);
+            }
+            let project_owner = self.projects().get(project_id).owner;
+            self.send().direct_multi(&project_owner, &output_payments);
+        }
+
+        self.pot_donations(potlock_id).clear();
+
+        //TODO: Clear all info regarding the pot?
+    }
+}

contracts/potlock/src/potlock_interactions.rs

@@ -0,0 +1,64 @@
+use crate::potlock_setup;
+use crate::potlock_storage::{self, Pot, Project};
+use crate::potlock_storage::{PotlockId, ProjectId};
+
+multiversx_sc::imports!();
+multiversx_sc::derive_imports!();
+
+#[multiversx_sc::module]
+pub trait PotlockInteractions:
+    potlock_storage::PotlockStorage
+    + potlock_setup::PotlockSetup
+    + multiversx_sc_modules::only_admin::OnlyAdminModule
+{
+    #[payable("*")]
+    #[endpoint(addPot)]
+    fn add_pot(&self, name: ManagedBuffer, description: ManagedBuffer) {
+        let payment_for_adding_pot = self.call_value().single_esdt();
+        require!(
+            self.fee_token_identifier().get() == payment_for_adding_pot.token_identifier,
+            "Wrong token identifier for creating a pot!"
+        );
+        require!(
+            self.fee_amount().get() == payment_for_adding_pot.amount,
+            "Wrong fee amount for creating a pot"
+        );
+        let caller = self.blockchain().get_caller();
+
+        let potlock_id = self.potlocks().len() + 1;
+        let potlock = Pot::new(potlock_id, name, description);
+        self.potlocks().push(&potlock);
+
+        self.fee_pot_proposer(potlock_id).set(caller);
+    }
+
+    #[endpoint(applyForPot)]
+    fn apply_for_pot(
+        &self,
+        potlock_id: PotlockId,
+        project_name: ManagedBuffer,
+        description: ManagedBuffer,
+    ) {
+        let project_id = self.projects().len() + 1;
+        let owner = self.blockchain().get_caller();
+        let project = Project::new(project_id, potlock_id, project_name, description, owner);
+        self.projects().push(&project);
+    }
+
+    #[payable("*")]
+    #[endpoint(donateToPot)]
+    fn donate_to_pot(&self, potlock_id: PotlockId) {
+        let payment = self.call_value().single_esdt();
+        let caller = self.blockchain().get_caller();
+        self.pot_donations(potlock_id).insert(caller, payment);
+    }
+
+    #[payable("*")]
+    #[endpoint(donateToProject)]
+    fn donate_to_project(&self, project_id: ProjectId) {
+        self.require_project_exists(project_id);
+        let payment = self.call_value().single_esdt();
+        let caller = self.blockchain().get_caller();
+        self.project_donations(project_id).insert(caller, payment);
+    }
+}

contracts/potlock/src/potlock_setup.rs

@@ -0,0 +1,42 @@
+use crate::potlock_storage::{self, PotlockId, ProjectId};
+
+multiversx_sc::imports!();
+
+#[multiversx_sc::module]
+pub trait PotlockSetup:
+    potlock_storage::PotlockStorage + multiversx_sc_modules::only_admin::OnlyAdminModule
+{
+    #[only_admin]
+    #[endpoint(changeFeeForPots)]
+    fn change_fee_for_pots(&self, token_identifier: TokenIdentifier, fee: BigUint) {
+        require!(
+            token_identifier.is_valid_esdt_identifier(),
+            "Invalid token provided"
+        );
+        self.fee_token_identifier().set(&token_identifier);
+        self.fee_amount().set(fee);
+    }
+
+    //// internal functions
+    fn is_valid_potlock_id(&self, potlock_id: PotlockId) -> bool {
+        potlock_id >= 1 && potlock_id <= self.potlocks().len()
+    }
+
+    fn require_potlock_exists(&self, potlock_id: PotlockId) {
+        require!(
+            self.is_valid_potlock_id(potlock_id) && !self.potlocks().item_is_empty(potlock_id),
+            "Potlock doesn't exist!",
+        )
+    }
+
+    fn is_valid_project_id(&self, project_id: ProjectId) -> bool {
+        project_id >= 1 && project_id <= self.projects().len()
+    }
+
+    fn require_project_exists(&self, project_id: ProjectId) {
+        require!(
+            self.is_valid_project_id(project_id) && !self.projects().item_is_empty(project_id),
+            "Project doesn't exist!",
+        )
+    }
+}