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,24 @@
+[package]
+name = "potlock"
+version = "0.0.0"
+authors = ["you"]
+edition = "2021"
+publish = false
+
+[lib]
+path = "src/potlock.rs"
+
+[dependencies.multiversx-sc]
+version = "0.50.4"
+
+[dev-dependencies]
+num-bigint = "0.4"
+
+[dev-dependencies.multiversx-sc-scenario]
+version = "0.50.4"
+
+[workspace]
+members = [
+    ".",
+    "meta",
+]

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.50.4"
+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,19 @@
+#![no_std]
+
+use multiversx_sc::imports::*;
+mod potlock_setup;
+mod potlock_storage;
+mod potlock_interactions;
+mod potlock_admin_interactions;
+
+/// 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 {
+    #[init]
+    fn init(&self, admin: ManagedAddress) {
+        self.admins().add(admin);
+    }
+
+    #[upgrade]
+    fn upgrade(&self) {}
+}

contracts/potlock/src/potlock_admin_interactions.rs

@@ -0,0 +1,71 @@
+multiversx_sc::imports!();
+multiversx_sc::derive_imports!();
+
+pub type ProjectPercentage = MultiValue2<usize, usize>;
+
+#[multiversx_sc::module]
+pub trait PotlockAdminInteractions:
+    crate::potlock::PotlockStorage + multiversx_sc_modules::only_admin::OnlyAdminModule
+{
+    #[only_admin]
+    #[endpoint(acceptPot)]
+    fn accept_pot(&self, potlock_id: PotlockId) {
+        require_potlock_exists(potlock_id);
+        // TODO: Common fund is another contract?
+    }
+
+    #[only_admin]
+    #[endpoint(rejectPot)]
+    fn reject_pot(&self, potlock_id: PotlockId) {
+        require_potlock_exists(potlock_id);
+
+        //TODO: Common fund is another contract?
+        //TODO: "will return the fee back to the user"
+
+        //TODO: Should we remove the potlock?
+        self.potlocks().clear_entry(proposal_id);
+    }
+
+    #[only_admin]
+    #[endpoint(removePot)]
+    fn remove_pot(&self, potlock_id: PotlockId) {
+        let caller = self.blockchain().get_caller();
+        let payment = self.fee_pot_payments(potlock_id, caller).get();
+
+        self.send().direct_non_zero_esdt_payment(&caller, &payment);
+        self.potlocks().clear_entry(proposal_id);
+    }
+
+    #[only_admin]
+    #[endpoint(acceptApplication)]
+    fn accept_application(&self, project: Projectid) {
+        require_potlock_exists(potlock_id);
+        // TODO: How should we KYC verification in the SC?
+    }
+    rejectDonation@userID@listOfTokens - returns tokens to the users.
+
+    #[only_admin]
+    #[endpoint(rejectDonation)]
+    fn reject_donation(&self, potlock: PotlockId, user: ManagedAddress) {
+        require_potlock_exists(potlock_id);
+        let fee_pot_payments = self.fee_pot_payments(potlock_id, user);
+        self.send().direct_non_zero_esdt_payment(&user, &fee_pot_payments);
+    }
+
+
+    #[only_admin]
+    #[endpoint(distributePotToProjects)]
+    fn distribute_pot_to_projects(&self, potlock: PotlockId, project_percentage: MultiValueEncoded<ProjectPercentage>) {
+        require_potlock_exists(potlock_id);
+        let potlock = self.potlocks().get();
+        for pp in project_percentage {
+            let (project_id, percentage) = pp.into_tuple();
+
+        }
+        // TODO: How should we KYC verification in the SC?
+    }
+
+    fn get_total_payments_for_pot(&self) {
+        let fee_pot_payments = self.fee_pot_payments().get();   
+    }
+}

contracts/potlock/src/potlock_interactions.rs

@@ -0,0 +1,50 @@
+multiversx_sc::imports!();
+multiversx_sc::derive_imports!();
+
+#[multiversx_sc::module]
+pub trait PotlockInteractions: crate::potlock::PotlockStorage {
+    #[payable("*")]
+    #[endpoint(addPot)]
+    fn add_pot(&self, name: ManagedBuffer, description: ManagedBuffer) {
+        let payment = self.call_value().egld_or_single_esdt().into_tuple();
+        require!(
+            self.fee_token_identifier().get() == payment.token_identifier,
+            "Wrong token identifier for creating a pot!"
+        );
+        require!(
+            self.fee_amount().get() == payment.amount,
+            "Wrong fee amount for creating a pot"
+        );
+        let caller = self.blockchain().get_caller();
+
+        let potlock = Potlock::new(name, description);
+        let potlock_id = self.potlocks().push(&potlock);
+        let fee_pot_payments = self.fee_pot_payments(potlock_id, caller).insert(payment);
+    }
+
+    #[endpoint(applyForPot)]
+    fn apply_for_pot(&self, project_name: ManagedBuffer, description: ManagedBuffer) {
+        // TODO: should we set a SC address as a parameter or assume (and verifiy) that the SC will call this endpoint
+        // TODO: This address will receive the funds
+        let caller = self.blockchain().get_caller();
+        let project = Project::new(name, description);
+        let project_id = self.projects().push(&project);
+    }
+
+    #[payable("*")]
+    #[endpoint(donateToPot)]
+    fn donate_to_pot(&self, potlock_id: PotlockId) {
+        let payment = self.call_value().egld_or_single_esdt().into_tuple();
+        let caller = self.blockchain().get_caller();
+        self.fee_pot_payments(potlock_id).insert(payment);
+    }
+
+    #[payable("*")]
+    #[endpoint(donateToProject)]
+    fn donate_to_project(&self, project_id: ProjectId) {
+        let payment = self.call_value().egld_or_single_esdt().into_tuple();
+        let caller = self.blockchain().get_caller();
+        self.fee_project_payments(project_id, caller)
+            .insert(payment);
+    }
+}

contracts/potlock/src/potlock_setup.rs

@@ -0,0 +1,30 @@
+multiversx_sc::imports!();
+multiversx_sc::derive_imports!();
+
+#[multiversx_sc::module]
+pub trait PotlockSetup:
+    crate::potlock::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.potlock().item_is_empty(potlock_id),
+            "Potlock doesn't exist!",
+        )
+    }
+}

contracts/potlock/src/potlock_storage.rs

@@ -0,0 +1,93 @@
+multiversx_sc::imports!();
+multiversx_sc::derive_imports!();
+
+pub type PotlockId = usize;
+pub type ProjectId = usize;
+
+#[derive(TypeAbi, TopEncode, TopDecode, PartialEq, Eq)]
+pub enum PotlockStatus {
+    None,
+    Active,
+    Inactive,
+}
+
+#[derive(
+    TypeAbi, NestedEncode, NestedDecode, PartialEq, Debug, TopEncodeOrDefault, TopDecodeOrDefault,
+)]
+pub struct Potlock<M: ManagedTypeApi> {
+    pub potlock_id: PotlocklId,
+    pub token_identifier: TokenIdentifier<M>,
+    pub fee: BigUint<M>,
+    pub name: ManagedBuffer<M>,
+    pub description: ManagedBuffer<M>,
+    pub status: PotlockStatus,
+    // pub payment: EsdtTokenPayment<M>,
+}
+
+impl<M: ManagedTypeApi> Default for Potlock<M> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl<M: ManagedTypeApi> Potlock<M> {
+    pub fn new(name: ManagedBuffer, description: ManagedBuffer) -> Self {
+        Potlock{
+            potlock_id: self.potlocks().len() + 1,
+            token_identifier: TokenIdentifier::from(ManagedBuffer::default()).
+            fee: BigUint::default(),
+            name,
+            description,
+        }
+    }
+}
+
+pub struct Project<M: ManagedTypeApi> {
+    pub project_id: PotlocklId,
+    pub name: ManagedBuffer<M>,
+    pub description: ManagedBuffer<M>,
+    pub address: ManagedAddress<M>,
+}
+
+impl<M: ManagedTypeApi> Default for Project<M> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl<M: ManagedTypeApi> Project<M> {
+    pub fn new(name: ManagedBuffer, description: ManagedBuffer) -> Self {
+        Project{
+            project_id: self.proposals().len() + 1,
+            name,
+            description,
+        }
+    }
+}
+
+#[multiversx_sc::module]
+pub trait PotlockStorage {
+    #[view(getFeeTokenIdentifier)]
+    #[storage_mapper("fee_token_identifier")]
+    fn fee_token_identifier(&self) -> SingleValueMapper<TokenIdentifier>;
+
+    #[view(getFeeAmount)]
+    #[storage_mapper("fee_amount")]
+    fn fee_amount(&self) -> SingleValueMapper<BigUint>;
+
+    #[view(getPotlocks)]
+    #[storage_mapper("potlocks")]
+    fn potlocks(&self) -> VecMapper<Potlock<Self::Api>>;
+
+    #[view(getProjects)]
+    #[storage_mapper("projects")]
+    fn projects(&self) -> VecMapper<Project<Self::Api>>;
+
+    #[view(feePotPayments)]
+    #[storage_mapper("fee_pot_payments")]
+    fn fee_pot_payments(&self, potlock_id: PotlockId, address: &ManagedAddress) -> UnorderedSetMapper<EsdtTokenPayment>;
+
+    #[view(feeProjectPayments)]
+    #[storage_mapper("fee_project_payments")]
+    fn fee_project_payments(&self, project_id: ProjectId, address: &ManagedAddress) -> UnorderedSetMapper<EsdtTokenPayment>;
+}

contracts/potlock/tests/potlock_scenario_go_test.rs

@@ -0,0 +1,10 @@
+use multiversx_sc_scenario::*;
+
+fn world() -> ScenarioWorld {
+    ScenarioWorld::vm_go()
+}
+
+#[test]
+fn empty_go() {
+    world().run("scenarios/potlock.scen.json");
+}

contracts/potlock/tests/potlock_scenario_rs_test.rs

@@ -0,0 +1,13 @@
+use multiversx_sc_scenario::*;
+
+fn world() -> ScenarioWorld {
+    let mut blockchain = ScenarioWorld::new();
+
+    blockchain.register_contract("mxsc:output/potlock.mxsc.json", potlock::ContractBuilder);
+    blockchain
+}
+
+#[test]
+fn empty_rs() {
+    world().run("scenarios/potlock.scen.json");
+}