errors

fee-market/interactor/.gitignore

@@ -0,0 +1,2 @@
+# Pem files are used for interactions, but shouldn't be committed
+*.pem

fee-market/interactor/Cargo.toml

@@ -0,0 +1,27 @@
+[package]
+name = "rust-interactor"
+version = "0.0.0"
+authors = ["you"]
+edition = "2021"
+publish = false
+
+[[bin]]
+name = "rust-interact"
+path = "src/interactor_main.rs"
+
+[dependencies.fee-market]
+path = ".."
+
+[dependencies.multiversx-sc-snippets]
+version = "0.53.0"
+
+[dependencies.multiversx-sc]
+version = "0.53.0"
+
+[dependencies]
+clap = { version = "4.4.7", features = ["derive"] }
+serde = { version = "1.0", features = ["derive"] }
+toml = "0.8.6"
+
+# [workspace]
+

fee-market/interactor/src/interactor_main.rs

@@ -0,0 +1,367 @@
+#![allow(non_snake_case)]
+
+mod proxy;
+
+use multiversx_sc_snippets::imports::*;
+use multiversx_sc_snippets::sdk;
+use proxy::FeeStruct;
+use serde::{Deserialize, Serialize};
+use std::{
+    io::{Read, Write},
+    path::Path,
+};
+
+
+const GATEWAY: &str = sdk::gateway::DEVNET_GATEWAY;
+const STATE_FILE: &str = "state.toml";
+
+
+#[tokio::main]
+async fn main() {
+    env_logger::init();
+
+    let mut args = std::env::args();
+    let _ = args.next();
+    let cmd = args.next().expect("at least one argument required");
+    let mut interact = ContractInteract::new().await;
+    match cmd.as_str() {
+        "deploy" => interact.deploy().await,
+        "upgrade" => interact.upgrade().await,
+        "addFee" => interact.set_fee().await,
+        "removeFee" => interact.disable_fee().await,
+        "getTokenFee" => interact.token_fee().await,
+        "addUsersToWhitelist" => interact.add_users_to_whitelist().await,
+        "removeUsersFromWhitelist" => interact.remove_users_from_whitelist().await,
+        "distributeFees" => interact.distribute_fees().await,
+        "subtractFee" => interact.subtract_fee().await,
+        "getUsersWhitelist" => interact.users_whitelist().await,
+        "setMinValidSigners" => interact.set_min_valid_signers().await,
+        "addSigners" => interact.add_signers().await,
+        "removeSigners" => interact.remove_signers().await,
+        _ => panic!("unknown command: {}", &cmd),
+    }
+}
+
+
+#[derive(Debug, Default, Serialize, Deserialize)]
+struct State {
+    contract_address: Option<Bech32Address>
+}
+
+impl State {
+        // Deserializes state from file
+        pub fn load_state() -> Self {
+            if Path::new(STATE_FILE).exists() {
+                let mut file = std::fs::File::open(STATE_FILE).unwrap();
+                let mut content = String::new();
+                file.read_to_string(&mut content).unwrap();
+                toml::from_str(&content).unwrap()
+            } else {
+                Self::default()
+            }
+        }
+
+        /// Sets the contract address
+        pub fn set_address(&mut self, address: Bech32Address) {
+            self.contract_address = Some(address);
+        }
+
+        /// Returns the contract address
+        pub fn current_address(&self) -> &Bech32Address {
+            self.contract_address
+                .as_ref()
+                .expect("no known contract, deploy first")
+        }
+    }
+
+    impl Drop for State {
+        // Serializes state to file
+        fn drop(&mut self) {
+            let mut file = std::fs::File::create(STATE_FILE).unwrap();
+            file.write_all(toml::to_string(self).unwrap().as_bytes())
+                .unwrap();
+        }
+    }
+
+struct ContractInteract {
+    interactor: Interactor,
+    wallet_address: Address,
+    contract_code: BytesValue,
+    state: State
+}
+
+impl ContractInteract {
+    async fn new() -> Self {
+        let mut interactor = Interactor::new(GATEWAY).await;
+        let wallet_address = interactor.register_wallet(test_wallets::alice());
+
+        let contract_code = BytesValue::interpret_from(
+            "mxsc:../output/fee-market.mxsc.json",
+            &InterpreterContext::default(),
+        );
+
+        ContractInteract {
+            interactor,
+            wallet_address,
+            contract_code,
+            state: State::load_state()
+        }
+    }
+
+    async fn deploy(&mut self) {
+        let esdt_safe_address = bech32::decode("");
+        let price_aggregator_address = bech32::decode("");
+        let fee = Option::Some(FeeStruct::<StaticApi>::default());
+        let new_address = self
+            .interactor
+            .tx()
+            .from(&self.wallet_address)
+            .gas(30_000_000u64)
+            .typed(proxy::FeeMarketProxy)
+            .init(esdt_safe_address, price_aggregator_address, fee)
+            .code(&self.contract_code)
+            .returns(ReturnsNewAddress)
+            .prepare_async()
+            .run()
+            .await;
+        let new_address_bech32 = bech32::encode(&new_address);
+        self.state
+            .set_address(Bech32Address::from_bech32_string(new_address_bech32.clone()));
+
+        println!("new address: {new_address_bech32}");
+    }
+
+    async fn upgrade(&mut self) {
+        let response = self
+            .interactor
+            .tx()
+            .to(self.state.current_address())
+            .from(&self.wallet_address)
+            .gas(30_000_000u64)
+            .typed(proxy::FeeMarketProxy)
+            .upgrade()
+            .code(&self.contract_code)
+            .code_metadata(CodeMetadata::UPGRADEABLE)
+            .returns(ReturnsNewAddress)
+            .prepare_async()
+            .run()
+            .await;
+
+        println!("Result: {response:?}");
+    }
+
+    async fn set_fee(&mut self) {
+        let base_token = TokenIdentifier::from_esdt_bytes(&b""[..]);
+        let fee_type = FeeType::<StaticApi>::default();
+
+        let response = self
+            .interactor
+            .tx()
+            .from(&self.wallet_address)
+            .to(self.state.current_address())
+            .gas(30_000_000u64)
+            .typed(proxy::FeeMarketProxy)
+            .set_fee(base_token, fee_type)
+            .returns(ReturnsResultUnmanaged)
+            .prepare_async()
+            .run()
+            .await;
+
+        println!("Result: {response:?}");
+    }
+
+    async fn disable_fee(&mut self) {
+        let base_token = TokenIdentifier::from_esdt_bytes(&b""[..]);
+
+        let response = self
+            .interactor
+            .tx()
+            .from(&self.wallet_address)
+            .to(self.state.current_address())
+            .gas(30_000_000u64)
+            .typed(proxy::FeeMarketProxy)
+            .disable_fee(base_token)
+            .returns(ReturnsResultUnmanaged)
+            .prepare_async()
+            .run()
+            .await;
+
+        println!("Result: {response:?}");
+    }
+
+    async fn token_fee(&mut self) {
+        let token_id = TokenIdentifier::from_esdt_bytes(&b""[..]);
+
+        let result_value = self
+            .interactor
+            .query()
+            .to(self.state.current_address())
+            .typed(proxy::FeeMarketProxy)
+            .token_fee(token_id)
+            .returns(ReturnsResultUnmanaged)
+            .prepare_async()
+            .run()
+            .await;
+
+        println!("Result: {result_value:?}");
+    }
+
+    async fn add_users_to_whitelist(&mut self) {
+        let users = MultiValueVec::from(vec![bech32::decode("")]);
+
+        let response = self
+            .interactor
+            .tx()
+            .from(&self.wallet_address)
+            .to(self.state.current_address())
+            .gas(30_000_000u64)
+            .typed(proxy::FeeMarketProxy)
+            .add_users_to_whitelist(users)
+            .returns(ReturnsResultUnmanaged)
+            .prepare_async()
+            .run()
+            .await;
+
+        println!("Result: {response:?}");
+    }
+
+    async fn remove_users_from_whitelist(&mut self) {
+        let users = MultiValueVec::from(vec![bech32::decode("")]);
+
+        let response = self
+            .interactor
+            .tx()
+            .from(&self.wallet_address)
+            .to(self.state.current_address())
+            .gas(30_000_000u64)
+            .typed(proxy::FeeMarketProxy)
+            .remove_users_from_whitelist(users)
+            .returns(ReturnsResultUnmanaged)
+            .prepare_async()
+            .run()
+            .await;
+
+        println!("Result: {response:?}");
+    }
+
+    async fn distribute_fees(&mut self) {
+        let mut address_percentage_pairs: MultiValueEncoded<
+            StaticApi,
+            MultiValue2<ManagedAddress<StaticApi>, usize>,
+        > = MultiValueEncoded::new();
+        address_percentage_pairs.push(MultiValue2((ManagedAddress::zero(), 0usize)));
+
+        let response = self
+            .interactor
+            .tx()
+            .from(&self.wallet_address)
+            .to(self.state.current_address())
+            .gas(30_000_000u64)
+            .typed(proxy::FeeMarketProxy)
+            .distribute_fees(address_percentage_pairs)
+            .returns(ReturnsResultUnmanaged)
+            .prepare_async()
+            .run()
+            .await;
+
+        println!("Result: {response:?}");
+    }
+
+    async fn subtract_fee(&mut self) {
+        let token_id = String::new();
+        let token_nonce = 0u64;
+        let token_amount = BigUint::<StaticApi>::from(0u128);
+
+        let original_caller = bech32::decode("");
+        let total_transfers = 0u32;
+        let opt_gas_limit = OptionalValue::Some(0u64);
+
+        let response = self
+            .interactor
+            .tx()
+            .from(&self.wallet_address)
+            .to(self.state.current_address())
+            .gas(30_000_000u64)
+            .typed(proxy::FeeMarketProxy)
+            .subtract_fee(original_caller, total_transfers, opt_gas_limit)
+            .payment((TokenIdentifier::from(token_id.as_str()), token_nonce, token_amount))
+            .returns(ReturnsResultUnmanaged)
+            .prepare_async()
+            .run()
+            .await;
+
+        println!("Result: {response:?}");
+    }
+
+    async fn users_whitelist(&mut self) {
+        let result_value = self
+            .interactor
+            .query()
+            .to(self.state.current_address())
+            .typed(proxy::FeeMarketProxy)
+            .users_whitelist()
+            .returns(ReturnsResultUnmanaged)
+            .prepare_async()
+            .run()
+            .await;
+
+        println!("Result: {result_value:?}");
+    }
+
+    async fn set_min_valid_signers(&mut self) {
+        let new_value = 0u32;
+
+        let response = self
+            .interactor
+            .tx()
+            .from(&self.wallet_address)
+            .to(self.state.current_address())
+            .gas(30_000_000u64)
+            .typed(proxy::FeeMarketProxy)
+            .set_min_valid_signers(new_value)
+            .returns(ReturnsResultUnmanaged)
+            .prepare_async()
+            .run()
+            .await;
+
+        println!("Result: {response:?}");
+    }
+
+    async fn add_signers(&mut self) {
+        let signers = MultiValueVec::from(vec![bech32::decode("")]);
+
+        let response = self
+            .interactor
+            .tx()
+            .from(&self.wallet_address)
+            .to(self.state.current_address())
+            .gas(30_000_000u64)
+            .typed(proxy::FeeMarketProxy)
+            .add_signers(signers)
+            .returns(ReturnsResultUnmanaged)
+            .prepare_async()
+            .run()
+            .await;
+
+        println!("Result: {response:?}");
+    }
+
+    async fn remove_signers(&mut self) {
+        let signers = MultiValueVec::from(vec![bech32::decode("")]);
+
+        let response = self
+            .interactor
+            .tx()
+            .from(&self.wallet_address)
+            .to(self.state.current_address())
+            .gas(30_000_000u64)
+            .typed(proxy::FeeMarketProxy)
+            .remove_signers(signers)
+            .returns(ReturnsResultUnmanaged)
+            .prepare_async()
+            .run()
+            .await;
+
+        println!("Result: {response:?}");
+    }
+}