From 4378754083f6aab94986adea3517b60adc792be4 Mon Sep 17 00:00:00 2001
From: Andrei Baltariu <andreibaltariu1304@gmail.com>
Date: Tue, 25 Jun 2024 15:37:07 +0300
Subject: [PATCH 01/76] Added new test file

---
 enshrine-esdt-safe/tests/enshrine_esdt_safe_blackbox_test.rs | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 enshrine-esdt-safe/tests/enshrine_esdt_safe_blackbox_test.rs

diff --git a/enshrine-esdt-safe/tests/enshrine_esdt_safe_blackbox_test.rs b/enshrine-esdt-safe/tests/enshrine_esdt_safe_blackbox_test.rs
new file mode 100644
index 00000000..e69de29b

From d1f743cbb4d197bb4eec7915f9c64d889a0f445b Mon Sep 17 00:00:00 2001
From: Andrei Baltariu <andreibaltariu1304@gmail.com>
Date: Tue, 25 Jun 2024 16:01:10 +0300
Subject: [PATCH 02/76] Deploy test

---
 .../tests/enshrine_esdt_safe_blackbox_test.rs | 61 +++++++++++++++++++
 .../enshrine_esdt_safe_scenario_go_test.rs    | 10 ---
 .../enshrine_esdt_safe_scenario_rs_test.rs    | 16 -----
 3 files changed, 61 insertions(+), 26 deletions(-)
 delete mode 100644 enshrine-esdt-safe/tests/enshrine_esdt_safe_scenario_go_test.rs
 delete mode 100644 enshrine-esdt-safe/tests/enshrine_esdt_safe_scenario_rs_test.rs

diff --git a/enshrine-esdt-safe/tests/enshrine_esdt_safe_blackbox_test.rs b/enshrine-esdt-safe/tests/enshrine_esdt_safe_blackbox_test.rs
index e69de29b..5cfd95ac 100644
--- a/enshrine-esdt-safe/tests/enshrine_esdt_safe_blackbox_test.rs
+++ b/enshrine-esdt-safe/tests/enshrine_esdt_safe_blackbox_test.rs
@@ -0,0 +1,61 @@
+use enshrine_esdt_safe::enshrine_esdt_safe_proxy;
+use multiversx_sc::types::{ManagedBuffer, TestAddress, TestSCAddress, TestTokenIdentifier};
+use multiversx_sc_scenario::ScenarioTxRun;
+use multiversx_sc_scenario::{imports::MxscPath, ScenarioWorld};
+
+const ENSHRINE_ESDT_ADDRESS: TestSCAddress = TestSCAddress::new("enshrine-esdt");
+const ENSHRINE_ESDT_CODE_PATH: MxscPath = MxscPath::new("output/enshrine-esdt-safe.mxsc-json");
+const ENSHRINE_ESDT_OWNER: TestAddress = TestAddress::new("enshrine-esdt-owner");
+
+const ENSHRINE_OWNER_BALANCE: u64 = 100_000_000;
+const USER_EGLD_BALANCE: u64 = 100_000_000;
+
+const NFT_TOKEN_ID: TestTokenIdentifier = TestTokenIdentifier::new("NFT-123456");
+const FUNGIBLE_TOKEN_ID: TestTokenIdentifier = TestTokenIdentifier::new("CROWD-123456");
+
+fn world() -> ScenarioWorld {
+    let mut blockchain = ScenarioWorld::new();
+
+    blockchain.register_contract(ENSHRINE_ESDT_CODE_PATH, enshrine_esdt_safe::ContractBuilder);
+
+    blockchain
+}
+
+struct EnshrineTestState {
+    world: ScenarioWorld,
+}
+
+impl EnshrineTestState {
+    fn new() -> Self {
+        let mut world = world();
+
+        world
+            .account(ENSHRINE_ESDT_OWNER)
+            .esdt_balance(FUNGIBLE_TOKEN_ID, 100_000)
+            .esdt_nft_balance(NFT_TOKEN_ID, 1, 100_000, ManagedBuffer::new())
+            .nonce(1)
+            .balance(ENSHRINE_OWNER_BALANCE);
+
+        Self { world }
+    }
+
+    fn deploy_enshrine_esdt_contract(&mut self, is_sovereign_chain: bool) -> &mut Self {
+        self.world
+            .tx()
+            .from(ENSHRINE_ESDT_OWNER)
+            .typed(enshrine_esdt_safe_proxy::EnshrineEsdtSafeProxy)
+            .init(is_sovereign_chain)
+            .code(ENSHRINE_ESDT_CODE_PATH)
+            .new_address(ENSHRINE_ESDT_ADDRESS)
+            .run();
+
+        self
+    }
+}
+
+#[test]
+fn test_deploy() {
+    let mut state = EnshrineTestState::new();
+
+    state.deploy_enshrine_esdt_contract(false);
+}
diff --git a/enshrine-esdt-safe/tests/enshrine_esdt_safe_scenario_go_test.rs b/enshrine-esdt-safe/tests/enshrine_esdt_safe_scenario_go_test.rs
deleted file mode 100644
index 18b3d1e7..00000000
--- a/enshrine-esdt-safe/tests/enshrine_esdt_safe_scenario_go_test.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-use multiversx_sc_scenario::*;
-
-fn world() -> ScenarioWorld {
-    ScenarioWorld::vm_go()
-}
-
-#[test]
-fn empty_go() {
-    world().run("scenarios/enshrine_esdt_safe.scen.json");
-}
diff --git a/enshrine-esdt-safe/tests/enshrine_esdt_safe_scenario_rs_test.rs b/enshrine-esdt-safe/tests/enshrine_esdt_safe_scenario_rs_test.rs
deleted file mode 100644
index 94ecba89..00000000
--- a/enshrine-esdt-safe/tests/enshrine_esdt_safe_scenario_rs_test.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-use multiversx_sc_scenario::*;
-
-fn world() -> ScenarioWorld {
-    let mut blockchain = ScenarioWorld::new();
-
-    blockchain.register_contract(
-        "mxsc:output/enshrine-esdt-safe.mxsc.json",
-        enshrine_esdt_safe::ContractBuilder,
-    );
-    blockchain
-}
-
-#[test]
-fn empty_rs() {
-    world().run("scenarios/enshrine_esdt_safe.scen.json");
-}

From 1710be63f6f4a271dec223726fa0eb458aaceff6 Mon Sep 17 00:00:00 2001
From: Andrei Baltariu <andreibaltariu1304@gmail.com>
Date: Wed, 26 Jun 2024 12:29:16 +0300
Subject: [PATCH 03/76] Modified setup + execute operation test

---
 .../tests/enshrine_esdt_safe_blackbox_test.rs | 105 +++++++++++++++++-
 1 file changed, 100 insertions(+), 5 deletions(-)

diff --git a/enshrine-esdt-safe/tests/enshrine_esdt_safe_blackbox_test.rs b/enshrine-esdt-safe/tests/enshrine_esdt_safe_blackbox_test.rs
index 5cfd95ac..36b53da1 100644
--- a/enshrine-esdt-safe/tests/enshrine_esdt_safe_blackbox_test.rs
+++ b/enshrine-esdt-safe/tests/enshrine_esdt_safe_blackbox_test.rs
@@ -1,15 +1,26 @@
 use enshrine_esdt_safe::enshrine_esdt_safe_proxy;
-use multiversx_sc::types::{ManagedBuffer, TestAddress, TestSCAddress, TestTokenIdentifier};
-use multiversx_sc_scenario::ScenarioTxRun;
+use multiversx_sc::codec::TopEncode;
+use multiversx_sc::types::{
+    Address, ManagedBuffer, ManagedVec, TestAddress, TestSCAddress, TestTokenIdentifier,
+};
+use multiversx_sc_scenario::api::StaticApi;
+use multiversx_sc_scenario::multiversx_chain_vm::crypto_functions::sha256;
 use multiversx_sc_scenario::{imports::MxscPath, ScenarioWorld};
+use multiversx_sc_scenario::{managed_address, ScenarioTxRun};
+use transaction::{
+    Operation, OperationData, OperationEsdtPayment, StolenFromFrameworkEsdtTokenData,
+};
 
 const ENSHRINE_ESDT_ADDRESS: TestSCAddress = TestSCAddress::new("enshrine-esdt");
 const ENSHRINE_ESDT_CODE_PATH: MxscPath = MxscPath::new("output/enshrine-esdt-safe.mxsc-json");
-const ENSHRINE_ESDT_OWNER: TestAddress = TestAddress::new("enshrine-esdt-owner");
+const ENSHRINE_ESDT_OWNER_ADDRESS: TestAddress = TestAddress::new("enshrine-esdt-owner");
 
 const ENSHRINE_OWNER_BALANCE: u64 = 100_000_000;
 const USER_EGLD_BALANCE: u64 = 100_000_000;
 
+const USER_ADDRESS: TestAddress = TestAddress::new("user");
+const RECEIVER_ADDRESS: TestAddress = TestAddress::new("receiver");
+
 const NFT_TOKEN_ID: TestTokenIdentifier = TestTokenIdentifier::new("NFT-123456");
 const FUNGIBLE_TOKEN_ID: TestTokenIdentifier = TestTokenIdentifier::new("CROWD-123456");
 
@@ -30,27 +41,102 @@ impl EnshrineTestState {
         let mut world = world();
 
         world
-            .account(ENSHRINE_ESDT_OWNER)
+            .account(ENSHRINE_ESDT_OWNER_ADDRESS)
             .esdt_balance(FUNGIBLE_TOKEN_ID, 100_000)
             .esdt_nft_balance(NFT_TOKEN_ID, 1, 100_000, ManagedBuffer::new())
             .nonce(1)
             .balance(ENSHRINE_OWNER_BALANCE);
 
+        world
+            .account(USER_ADDRESS)
+            .esdt_nft_balance(NFT_TOKEN_ID, 1, 100_000, ManagedBuffer::new())
+            .esdt_balance(FUNGIBLE_TOKEN_ID, 100_000)
+            .balance(USER_EGLD_BALANCE)
+            .nonce(1);
+
+        world.account(RECEIVER_ADDRESS).nonce(1);
+
         Self { world }
     }
 
     fn deploy_enshrine_esdt_contract(&mut self, is_sovereign_chain: bool) -> &mut Self {
         self.world
             .tx()
-            .from(ENSHRINE_ESDT_OWNER)
+            .from(ENSHRINE_ESDT_OWNER_ADDRESS)
             .typed(enshrine_esdt_safe_proxy::EnshrineEsdtSafeProxy)
             .init(is_sovereign_chain)
             .code(ENSHRINE_ESDT_CODE_PATH)
             .new_address(ENSHRINE_ESDT_ADDRESS)
             .run();
 
+        self.propose_set_unpaused();
+
         self
     }
+
+    fn propose_execute_operation(&mut self) {
+        let (tokens, data) = self.setup_payments(vec![NFT_TOKEN_ID, FUNGIBLE_TOKEN_ID]);
+        let to = managed_address!(&Address::from(&RECEIVER_ADDRESS.eval_to_array()));
+        let operation = Operation { to, tokens, data };
+        let operation_hash = self.get_operation_hash(&operation);
+        let hash_of_hashes: ManagedBuffer<StaticApi> =
+            ManagedBuffer::from(&sha256(&operation_hash.to_vec()));
+
+        self.world
+            .tx()
+            .from(USER_ADDRESS)
+            .to(ENSHRINE_ESDT_ADDRESS)
+            .typed(enshrine_esdt_safe_proxy::EnshrineEsdtSafeProxy)
+            .execute_operations(hash_of_hashes, operation)
+            .run();
+    }
+
+    fn propose_set_unpaused(&mut self) {
+        self.world
+            .tx()
+            .from(ENSHRINE_ESDT_OWNER_ADDRESS)
+            .to(ENSHRINE_ESDT_ADDRESS)
+            .typed(enshrine_esdt_safe_proxy::EnshrineEsdtSafeProxy)
+            .unpause_endpoint()
+            .run();
+    }
+
+    fn setup_payments(
+        &mut self,
+        token_ids: Vec<TestTokenIdentifier>,
+    ) -> (
+        ManagedVec<StaticApi, OperationEsdtPayment<StaticApi>>,
+        OperationData<StaticApi>,
+    ) {
+        let mut tokens: ManagedVec<StaticApi, OperationEsdtPayment<StaticApi>> = ManagedVec::new();
+
+        for token_id in token_ids {
+            let payment: OperationEsdtPayment<StaticApi> = OperationEsdtPayment {
+                token_identifier: token_id.into(),
+                token_nonce: 1,
+                token_data: StolenFromFrameworkEsdtTokenData::default(),
+            };
+
+            tokens.push(payment);
+        }
+
+        let op_sender = managed_address!(&Address::from(&USER_ADDRESS.eval_to_array()));
+        let data: OperationData<StaticApi> = OperationData {
+            op_nonce: 1,
+            op_sender,
+            opt_transfer_data: Option::None,
+        };
+
+        (tokens, data)
+    }
+
+    fn get_operation_hash(&mut self, operation: &Operation<StaticApi>) -> ManagedBuffer<StaticApi> {
+        let mut serialized_operation: ManagedBuffer<StaticApi> = ManagedBuffer::new();
+        let _ = operation.top_encode(&mut serialized_operation);
+        let sha256 = sha256(&serialized_operation.to_vec());
+
+        ManagedBuffer::new_from_bytes(&sha256)
+    }
 }
 
 #[test]
@@ -59,3 +145,12 @@ fn test_deploy() {
 
     state.deploy_enshrine_esdt_contract(false);
 }
+
+#[test]
+fn test_sovereign_prefix() {
+    let mut state = EnshrineTestState::new();
+
+    state.deploy_enshrine_esdt_contract(false);
+
+    state.propose_execute_operation();
+}

From 3fd293f16c50f491f7b3e6b64bbdf60ec863c0af Mon Sep 17 00:00:00 2001
From: Andrei Baltariu <andreibaltariu1304@gmail.com>
Date: Wed, 26 Jun 2024 12:37:13 +0300
Subject: [PATCH 04/76] Added header verifier address method

---
 .../tests/enshrine_esdt_safe_blackbox_test.rs | 48 +++++++++++++++++--
 1 file changed, 45 insertions(+), 3 deletions(-)

diff --git a/enshrine-esdt-safe/tests/enshrine_esdt_safe_blackbox_test.rs b/enshrine-esdt-safe/tests/enshrine_esdt_safe_blackbox_test.rs
index 36b53da1..7a954182 100644
--- a/enshrine-esdt-safe/tests/enshrine_esdt_safe_blackbox_test.rs
+++ b/enshrine-esdt-safe/tests/enshrine_esdt_safe_blackbox_test.rs
@@ -1,7 +1,9 @@
 use enshrine_esdt_safe::enshrine_esdt_safe_proxy;
+use header_verifier::header_verifier_proxy;
 use multiversx_sc::codec::TopEncode;
 use multiversx_sc::types::{
-    Address, ManagedBuffer, ManagedVec, TestAddress, TestSCAddress, TestTokenIdentifier,
+    Address, ManagedBuffer, ManagedVec, MultiValueEncoded, TestAddress, TestSCAddress,
+    TestTokenIdentifier,
 };
 use multiversx_sc_scenario::api::StaticApi;
 use multiversx_sc_scenario::multiversx_chain_vm::crypto_functions::sha256;
@@ -18,6 +20,10 @@ const ENSHRINE_ESDT_OWNER_ADDRESS: TestAddress = TestAddress::new("enshrine-esdt
 const ENSHRINE_OWNER_BALANCE: u64 = 100_000_000;
 const USER_EGLD_BALANCE: u64 = 100_000_000;
 
+const HEADER_VERIFIER_ADDRESS: TestSCAddress = TestSCAddress::new("header_verifier");
+const HEADER_VERIFIER_CODE_PATH: MxscPath =
+    MxscPath::new("../header-verifier/output/header-verifier.mxsc.json");
+
 const USER_ADDRESS: TestAddress = TestAddress::new("user");
 const RECEIVER_ADDRESS: TestAddress = TestAddress::new("receiver");
 
@@ -28,6 +34,7 @@ fn world() -> ScenarioWorld {
     let mut blockchain = ScenarioWorld::new();
 
     blockchain.register_contract(ENSHRINE_ESDT_CODE_PATH, enshrine_esdt_safe::ContractBuilder);
+    blockchain.register_contract(HEADER_VERIFIER_CODE_PATH, header_verifier::ContractBuilder);
 
     blockchain
 }
@@ -74,6 +81,31 @@ impl EnshrineTestState {
         self
     }
 
+    fn deploy_header_verifier_contract(&mut self) -> &mut Self {
+        let bls_pub_key: ManagedBuffer<StaticApi> = ManagedBuffer::new();
+        let mut bls_pub_keys = MultiValueEncoded::new();
+        bls_pub_keys.push(bls_pub_key);
+
+        self.world
+            .tx()
+            .from(ENSHRINE_ESDT_OWNER_ADDRESS)
+            .typed(header_verifier_proxy::HeaderverifierProxy)
+            .init(bls_pub_keys)
+            .code(HEADER_VERIFIER_CODE_PATH)
+            .new_address(HEADER_VERIFIER_ADDRESS)
+            .run();
+
+        self
+    }
+
+    fn propose_setup_contracts(&mut self, is_sovereign_chain: bool) -> &mut Self {
+        self.deploy_enshrine_esdt_contract(is_sovereign_chain);
+        self.deploy_header_verifier_contract();
+        self.propose_set_header_verifier_address();
+
+        self
+    }
+
     fn propose_execute_operation(&mut self) {
         let (tokens, data) = self.setup_payments(vec![NFT_TOKEN_ID, FUNGIBLE_TOKEN_ID]);
         let to = managed_address!(&Address::from(&RECEIVER_ADDRESS.eval_to_array()));
@@ -101,6 +133,16 @@ impl EnshrineTestState {
             .run();
     }
 
+    fn propose_set_header_verifier_address(&mut self) {
+        self.world
+            .tx()
+            .from(ENSHRINE_ESDT_OWNER_ADDRESS)
+            .to(ENSHRINE_ESDT_ADDRESS)
+            .typed(enshrine_esdt_safe_proxy::EnshrineEsdtSafeProxy)
+            .set_header_verifier_address(HEADER_VERIFIER_ADDRESS)
+            .run();
+    }
+
     fn setup_payments(
         &mut self,
         token_ids: Vec<TestTokenIdentifier>,
@@ -143,14 +185,14 @@ impl EnshrineTestState {
 fn test_deploy() {
     let mut state = EnshrineTestState::new();
 
-    state.deploy_enshrine_esdt_contract(false);
+    state.propose_setup_contracts(false);
 }
 
 #[test]
 fn test_sovereign_prefix() {
     let mut state = EnshrineTestState::new();
 
-    state.deploy_enshrine_esdt_contract(false);
+    state.propose_setup_contracts(false);
 
     state.propose_execute_operation();
 }

From defe670fe222f33b1a8b74f6f3e6b681e8260977 Mon Sep 17 00:00:00 2001
From: Andrei Baltariu <andreibaltariu1304@gmail.com>
Date: Wed, 26 Jun 2024 13:44:26 +0300
Subject: [PATCH 05/76] Modified has_prefix function and test

---
 common/utils/src/lib.rs                       |  7 ++-
 .../tests/enshrine_esdt_safe_blackbox_test.rs | 43 +++++++++++++++++--
 2 files changed, 43 insertions(+), 7 deletions(-)

diff --git a/common/utils/src/lib.rs b/common/utils/src/lib.rs
index 3886fe55..6720dc84 100644
--- a/common/utils/src/lib.rs
+++ b/common/utils/src/lib.rs
@@ -68,10 +68,9 @@ pub trait UtilsModule: bls_signature::BlsSignatureModule {
 
     fn has_sov_token_prefix(&self, token_id: &TokenIdentifier) -> bool {
         let dash = b'-';
-        let mut array_buffer = [0u8, 30];
-        let slice = token_id
-            .as_managed_buffer()
-            .load_to_byte_array(&mut array_buffer);
+        let buffer = token_id.as_managed_buffer();
+        let mut array_buffer = [0u8, 32];
+        let slice = buffer.load_to_byte_array(&mut array_buffer);
 
         let counter = slice.iter().filter(|&&c| c == dash).count();
 
diff --git a/enshrine-esdt-safe/tests/enshrine_esdt_safe_blackbox_test.rs b/enshrine-esdt-safe/tests/enshrine_esdt_safe_blackbox_test.rs
index 7a954182..02209602 100644
--- a/enshrine-esdt-safe/tests/enshrine_esdt_safe_blackbox_test.rs
+++ b/enshrine-esdt-safe/tests/enshrine_esdt_safe_blackbox_test.rs
@@ -1,9 +1,10 @@
+use bls_signature::BlsSignature;
 use enshrine_esdt_safe::enshrine_esdt_safe_proxy;
 use header_verifier::header_verifier_proxy;
 use multiversx_sc::codec::TopEncode;
 use multiversx_sc::types::{
-    Address, ManagedBuffer, ManagedVec, MultiValueEncoded, TestAddress, TestSCAddress,
-    TestTokenIdentifier,
+    Address, ManagedBuffer, ManagedByteArray, ManagedVec, MultiValueEncoded, TestAddress,
+    TestSCAddress, TestTokenIdentifier,
 };
 use multiversx_sc_scenario::api::StaticApi;
 use multiversx_sc_scenario::multiversx_chain_vm::crypto_functions::sha256;
@@ -143,6 +144,42 @@ impl EnshrineTestState {
             .run();
     }
 
+    fn propose_register_operation(&mut self) {
+        let (tokens, data) = self.setup_payments(vec![NFT_TOKEN_ID, FUNGIBLE_TOKEN_ID]);
+        let to = managed_address!(&Address::from(RECEIVER_ADDRESS.eval_to_array()));
+        let operation = Operation { to, tokens, data };
+        let operation_hash = self.get_operation_hash(&operation);
+        let mut operations_hashes = MultiValueEncoded::new();
+
+        operations_hashes.push(operation_hash.clone());
+
+        let mock_signature = self.mock_bls_signature(&operation_hash);
+        let hash_of_hashes = ManagedBuffer::new_from_bytes(&sha256(&operation_hash.to_vec()));
+
+        self.world
+            .tx()
+            .from(ENSHRINE_ESDT_OWNER_ADDRESS)
+            .to(HEADER_VERIFIER_ADDRESS)
+            .typed(header_verifier_proxy::HeaderverifierProxy)
+            .register_bridge_operations(
+                mock_signature,
+                hash_of_hashes.clone(),
+                operations_hashes.clone(),
+            )
+            .run();
+    }
+
+    fn mock_bls_signature(
+        &mut self,
+        operation_hash: &ManagedBuffer<StaticApi>,
+    ) -> BlsSignature<StaticApi> {
+        let byte_arr: &mut [u8; 48] = &mut [0; 48];
+        operation_hash.load_to_byte_array(byte_arr);
+        let mock_signature: BlsSignature<StaticApi> = ManagedByteArray::new_from_bytes(byte_arr);
+
+        mock_signature
+    }
+
     fn setup_payments(
         &mut self,
         token_ids: Vec<TestTokenIdentifier>,
@@ -193,6 +230,6 @@ fn test_sovereign_prefix() {
     let mut state = EnshrineTestState::new();
 
     state.propose_setup_contracts(false);
-
+    state.propose_register_operation();
     state.propose_execute_operation();
 }

From fb815db8e884ad1cd9b936d3cbd71892082a854f Mon Sep 17 00:00:00 2001
From: Andrei Baltariu <andreibaltariu1304@gmail.com>
Date: Wed, 26 Jun 2024 15:15:42 +0300
Subject: [PATCH 06/76] Fixed has_prefix error

---
 common/utils/src/lib.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/common/utils/src/lib.rs b/common/utils/src/lib.rs
index 6720dc84..a23551a7 100644
--- a/common/utils/src/lib.rs
+++ b/common/utils/src/lib.rs
@@ -69,7 +69,7 @@ pub trait UtilsModule: bls_signature::BlsSignatureModule {
     fn has_sov_token_prefix(&self, token_id: &TokenIdentifier) -> bool {
         let dash = b'-';
         let buffer = token_id.as_managed_buffer();
-        let mut array_buffer = [0u8, 32];
+        let mut array_buffer = [0u8; 32];
         let slice = buffer.load_to_byte_array(&mut array_buffer);
 
         let counter = slice.iter().filter(|&&c| c == dash).count();

From 996827641a80bbf201968110c8ae4aadcdb04328 Mon Sep 17 00:00:00 2001
From: Andrei Baltariu <andreibaltariu1304@gmail.com>
Date: Wed, 26 Jun 2024 15:43:44 +0300
Subject: [PATCH 07/76] Modified tests setup

---
 .../tests/enshrine_esdt_safe_blackbox_test.rs | 32 +++++++++++++++----
 1 file changed, 25 insertions(+), 7 deletions(-)

diff --git a/enshrine-esdt-safe/tests/enshrine_esdt_safe_blackbox_test.rs b/enshrine-esdt-safe/tests/enshrine_esdt_safe_blackbox_test.rs
index 02209602..6b5b11c3 100644
--- a/enshrine-esdt-safe/tests/enshrine_esdt_safe_blackbox_test.rs
+++ b/enshrine-esdt-safe/tests/enshrine_esdt_safe_blackbox_test.rs
@@ -30,6 +30,7 @@ const RECEIVER_ADDRESS: TestAddress = TestAddress::new("receiver");
 
 const NFT_TOKEN_ID: TestTokenIdentifier = TestTokenIdentifier::new("NFT-123456");
 const FUNGIBLE_TOKEN_ID: TestTokenIdentifier = TestTokenIdentifier::new("CROWD-123456");
+const PREFIX_NFT_TOKEN_ID: TestTokenIdentifier = TestTokenIdentifier::new("SOV-NFT-123456");
 
 fn world() -> ScenarioWorld {
     let mut blockchain = ScenarioWorld::new();
@@ -107,8 +108,12 @@ impl EnshrineTestState {
         self
     }
 
-    fn propose_execute_operation(&mut self) {
-        let (tokens, data) = self.setup_payments(vec![NFT_TOKEN_ID, FUNGIBLE_TOKEN_ID]);
+    fn propose_execute_operation(&mut self, has_prefix: bool) {
+        let (tokens, data) = if has_prefix {
+            self.setup_payments(vec![PREFIX_NFT_TOKEN_ID, FUNGIBLE_TOKEN_ID])
+        } else {
+            self.setup_payments(vec![NFT_TOKEN_ID, FUNGIBLE_TOKEN_ID])
+        };
         let to = managed_address!(&Address::from(&RECEIVER_ADDRESS.eval_to_array()));
         let operation = Operation { to, tokens, data };
         let operation_hash = self.get_operation_hash(&operation);
@@ -144,8 +149,12 @@ impl EnshrineTestState {
             .run();
     }
 
-    fn propose_register_operation(&mut self) {
-        let (tokens, data) = self.setup_payments(vec![NFT_TOKEN_ID, FUNGIBLE_TOKEN_ID]);
+    fn propose_register_operation(&mut self, has_prefix: bool) {
+        let (tokens, data) = if has_prefix {
+            self.setup_payments(vec![PREFIX_NFT_TOKEN_ID, FUNGIBLE_TOKEN_ID])
+        } else {
+            self.setup_payments(vec![NFT_TOKEN_ID, FUNGIBLE_TOKEN_ID])
+        };
         let to = managed_address!(&Address::from(RECEIVER_ADDRESS.eval_to_array()));
         let operation = Operation { to, tokens, data };
         let operation_hash = self.get_operation_hash(&operation);
@@ -226,10 +235,19 @@ fn test_deploy() {
 }
 
 #[test]
-fn test_sovereign_prefix() {
+fn test_sovereign_prefix_no_prefix() {
     let mut state = EnshrineTestState::new();
 
     state.propose_setup_contracts(false);
-    state.propose_register_operation();
-    state.propose_execute_operation();
+    state.propose_register_operation(false);
+    state.propose_execute_operation(false);
 }
+
+// #[test]
+// fn test_sovereign_prefix_has_prefix() {
+//     let mut state = EnshrineTestState::new();
+//
+//     state.propose_setup_contracts(false);
+//     state.propose_register_operation(true);
+//     state.propose_execute_operation(true);
+// }

From ec7ce342ffa34e78231a0f37a4110f82beafd200 Mon Sep 17 00:00:00 2001
From: Andrei Baltariu <andreibaltariu1304@gmail.com>
Date: Thu, 27 Jun 2024 13:35:44 +0300
Subject: [PATCH 08/76] Fixed failing test

---
 .../tests/enshrine_esdt_safe_blackbox_test.rs | 52 ++++++++++++-------
 1 file changed, 34 insertions(+), 18 deletions(-)

diff --git a/enshrine-esdt-safe/tests/enshrine_esdt_safe_blackbox_test.rs b/enshrine-esdt-safe/tests/enshrine_esdt_safe_blackbox_test.rs
index 6b5b11c3..e69e72ba 100644
--- a/enshrine-esdt-safe/tests/enshrine_esdt_safe_blackbox_test.rs
+++ b/enshrine-esdt-safe/tests/enshrine_esdt_safe_blackbox_test.rs
@@ -9,7 +9,7 @@ use multiversx_sc::types::{
 use multiversx_sc_scenario::api::StaticApi;
 use multiversx_sc_scenario::multiversx_chain_vm::crypto_functions::sha256;
 use multiversx_sc_scenario::{imports::MxscPath, ScenarioWorld};
-use multiversx_sc_scenario::{managed_address, ScenarioTxRun};
+use multiversx_sc_scenario::{managed_address, ExpectError, ScenarioTxRun};
 use transaction::{
     Operation, OperationData, OperationEsdtPayment, StolenFromFrameworkEsdtTokenData,
 };
@@ -108,7 +108,7 @@ impl EnshrineTestState {
         self
     }
 
-    fn propose_execute_operation(&mut self, has_prefix: bool) {
+    fn propose_execute_operation(&mut self, has_prefix: bool, error_msg: Option<&str>) {
         let (tokens, data) = if has_prefix {
             self.setup_payments(vec![PREFIX_NFT_TOKEN_ID, FUNGIBLE_TOKEN_ID])
         } else {
@@ -120,13 +120,28 @@ impl EnshrineTestState {
         let hash_of_hashes: ManagedBuffer<StaticApi> =
             ManagedBuffer::from(&sha256(&operation_hash.to_vec()));
 
-        self.world
-            .tx()
-            .from(USER_ADDRESS)
-            .to(ENSHRINE_ESDT_ADDRESS)
-            .typed(enshrine_esdt_safe_proxy::EnshrineEsdtSafeProxy)
-            .execute_operations(hash_of_hashes, operation)
-            .run();
+        match error_msg {
+            Some(msg) => {
+                self.world
+                    .tx()
+                    .from(USER_ADDRESS)
+                    .to(ENSHRINE_ESDT_ADDRESS)
+                    .typed(enshrine_esdt_safe_proxy::EnshrineEsdtSafeProxy)
+                    .execute_operations(hash_of_hashes, operation)
+                    .returns(ExpectError(10, msg))
+                    .run();
+            }
+
+            None => {
+                self.world
+                    .tx()
+                    .from(USER_ADDRESS)
+                    .to(ENSHRINE_ESDT_ADDRESS)
+                    .typed(enshrine_esdt_safe_proxy::EnshrineEsdtSafeProxy)
+                    .execute_operations(hash_of_hashes, operation)
+                    .run();
+            }
+        }
     }
 
     fn propose_set_unpaused(&mut self) {
@@ -240,14 +255,15 @@ fn test_sovereign_prefix_no_prefix() {
 
     state.propose_setup_contracts(false);
     state.propose_register_operation(false);
-    state.propose_execute_operation(false);
+    state.propose_execute_operation(false, None);
 }
 
-// #[test]
-// fn test_sovereign_prefix_has_prefix() {
-//     let mut state = EnshrineTestState::new();
-//
-//     state.propose_setup_contracts(false);
-//     state.propose_register_operation(true);
-//     state.propose_execute_operation(true);
-// }
+#[test]
+fn test_sovereign_prefix_has_prefix() {
+    let mut state = EnshrineTestState::new();
+    let error_message = "action is not allowed";
+
+    state.propose_setup_contracts(false);
+    state.propose_register_operation(true);
+    state.propose_execute_operation(true, Some(error_message));
+}

From 14e326f93194bd2a8c3a1a9486f45cecf8a3cd31 Mon Sep 17 00:00:00 2001
From: Andrei Baltariu <andreibaltariu1304@gmail.com>
Date: Fri, 28 Jun 2024 12:40:42 +0300
Subject: [PATCH 09/76] Added mapper and inline function

---
 .../src/from_sovereign/transfer_tokens.rs     | 20 ++++++++++++++++++-
 .../tests/enshrine_esdt_safe_blackbox_test.rs |  2 +-
 2 files changed, 20 insertions(+), 2 deletions(-)

diff --git a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
index 3bdd37ec..349b65c5 100644
--- a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
+++ b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
@@ -45,18 +45,26 @@ pub trait TransferTokensModule:
         self.distribute_payments(hash_of_hashes, operation_tuple, minted_operation_tokens);
     }
 
+    //TODO: register_token payable endpoint
+
     fn mint_tokens(
         &self,
         operation_tokens: &ManagedVec<OperationEsdtPayment<Self::Api>>,
     ) -> ManagedVec<OperationEsdtPayment<Self::Api>> {
         let mut output_payments = ManagedVec::new();
+        let mut wegld_amount = 0;
 
         for operation_token in operation_tokens.iter() {
-            if !self.has_sov_token_prefix(&operation_token.token_identifier) {
+            // TODO: check WEGLD -> continue
+            let has_sov_token_prefix = self.has_sov_token_prefix(&operation_token.token_identifier);
+
+            if !has_sov_token_prefix {
                 output_payments.push(operation_token.clone());
                 continue;
             }
 
+            // TODO: check storage + subtract 0.05 WEGLD
+
             let mut nonce = operation_token.token_nonce;
             if nonce == 0 {
                 self.send().esdt_local_mint(
@@ -111,6 +119,8 @@ pub trait TransferTokensModule:
             });
         }
 
+        // TODO: send remaining WEGLD to transfer_data.sender
+
         output_payments
     }
 
@@ -268,9 +278,17 @@ pub trait TransferTokensModule:
         }
     }
 
+    #[inline]
+    fn was_token_minted(&self, token_id: &TokenIdentifier<Self::Api>) -> bool {
+        self.paid_issued_tokens().contains(token_id)
+    }
+
     #[storage_mapper("pending_hashes")]
     fn pending_hashes(&self, hash_of_hashes: &ManagedBuffer) -> UnorderedSetMapper<ManagedBuffer>;
 
     #[storage_mapper("header_verifier_address")]
     fn header_verifier_address(&self) -> SingleValueMapper<ManagedAddress>;
+
+    #[storage_mapper("mintedTokens")]
+    fn paid_issued_tokens(&self) -> UnorderedSetMapper<TokenIdentifier<Self::Api>>;
 }
diff --git a/enshrine-esdt-safe/tests/enshrine_esdt_safe_blackbox_test.rs b/enshrine-esdt-safe/tests/enshrine_esdt_safe_blackbox_test.rs
index e69e72ba..4ddf09b5 100644
--- a/enshrine-esdt-safe/tests/enshrine_esdt_safe_blackbox_test.rs
+++ b/enshrine-esdt-safe/tests/enshrine_esdt_safe_blackbox_test.rs
@@ -30,7 +30,7 @@ const RECEIVER_ADDRESS: TestAddress = TestAddress::new("receiver");
 
 const NFT_TOKEN_ID: TestTokenIdentifier = TestTokenIdentifier::new("NFT-123456");
 const FUNGIBLE_TOKEN_ID: TestTokenIdentifier = TestTokenIdentifier::new("CROWD-123456");
-const PREFIX_NFT_TOKEN_ID: TestTokenIdentifier = TestTokenIdentifier::new("SOV-NFT-123456");
+const PREFIX_NFT_TOKEN_ID: TestTokenIdentifier = TestTokenIdentifier::new("sov-NFT-123456");
 
 fn world() -> ScenarioWorld {
     let mut blockchain = ScenarioWorld::new();

From 36e870e28ef5414a5c8ba4cfde5e5e76e9f00b7a Mon Sep 17 00:00:00 2001
From: Andrei Baltariu <andreibaltariu1304@gmail.com>
Date: Fri, 28 Jun 2024 13:20:59 +0300
Subject: [PATCH 10/76] Modified mint to logic for wegld fee

---
 .../src/from_sovereign/transfer_tokens.rs     | 33 ++++++++++++++++---
 1 file changed, 29 insertions(+), 4 deletions(-)

diff --git a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
index 349b65c5..10ca987c 100644
--- a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
+++ b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
@@ -7,6 +7,7 @@ use transaction::{GasLimit, Operation, OperationData, OperationEsdtPayment, Oper
 
 const CALLBACK_GAS: GasLimit = 10_000_000; // Increase if not enough
 const TRANSACTION_GAS: GasLimit = 30_000_000;
+const WEGLD_ID: &str = "WEGLD-bd4d79";
 
 #[multiversx_sc::module]
 pub trait TransferTokensModule:
@@ -36,7 +37,8 @@ pub trait TransferTokensModule:
             sc_panic!("Operation is not registered");
         }
 
-        let minted_operation_tokens = self.mint_tokens(&operation.tokens);
+        let minted_operation_tokens =
+            self.mint_tokens(&operation.data.op_sender, &operation.tokens);
         let operation_tuple = OperationTuple {
             op_hash: operation_hash,
             operation,
@@ -46,16 +48,21 @@ pub trait TransferTokensModule:
     }
 
     //TODO: register_token payable endpoint
+    // require x amount wegld
 
     fn mint_tokens(
         &self,
+        sender: &ManagedAddress<Self::Api>,
         operation_tokens: &ManagedVec<OperationEsdtPayment<Self::Api>>,
     ) -> ManagedVec<OperationEsdtPayment<Self::Api>> {
         let mut output_payments = ManagedVec::new();
-        let mut wegld_amount = 0;
+        let mut wegld_amount = BigUint::from(0u32);
 
         for operation_token in operation_tokens.iter() {
-            // TODO: check WEGLD -> continue
+            if self.is_wegld_identifier(&operation_token.token_identifier) {
+                continue;
+            }
+
             let has_sov_token_prefix = self.has_sov_token_prefix(&operation_token.token_identifier);
 
             if !has_sov_token_prefix {
@@ -65,6 +72,12 @@ pub trait TransferTokensModule:
 
             // TODO: check storage + subtract 0.05 WEGLD
 
+            if self.was_token_minted(&operation_token.token_identifier) {
+                continue;
+            }
+
+            wegld_amount += &operation_token.token_data.amount;
+
             let mut nonce = operation_token.token_nonce;
             if nonce == 0 {
                 self.send().esdt_local_mint(
@@ -119,7 +132,14 @@ pub trait TransferTokensModule:
             });
         }
 
-        // TODO: send remaining WEGLD to transfer_data.sender
+        let sc_address = self.blockchain().get_sc_address();
+        let payment = EsdtTokenPayment::new(WEGLD_ID.into(), 0, wegld_amount);
+
+        self.tx()
+            .from(sc_address)
+            .to(sender)
+            .esdt(payment)
+            .transfer();
 
         output_payments
     }
@@ -283,6 +303,11 @@ pub trait TransferTokensModule:
         self.paid_issued_tokens().contains(token_id)
     }
 
+    #[inline]
+    fn is_wegld_identifier(&self, token_id: &TokenIdentifier<Self::Api>) -> bool {
+        token_id.eq(&TokenIdentifier::from(WEGLD_ID))
+    }
+
     #[storage_mapper("pending_hashes")]
     fn pending_hashes(&self, hash_of_hashes: &ManagedBuffer) -> UnorderedSetMapper<ManagedBuffer>;
 

From d0aaea1a2f45161cb748a4b7bebb7dda5abecb36 Mon Sep 17 00:00:00 2001
From: Andrei Baltariu <andreibaltariu1304@gmail.com>
Date: Fri, 28 Jun 2024 13:51:31 +0300
Subject: [PATCH 11/76] Added register_tokens endpoint

---
 .../src/from_sovereign/transfer_tokens.rs         | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
index 10ca987c..570af898 100644
--- a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
+++ b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
@@ -8,6 +8,7 @@ use transaction::{GasLimit, Operation, OperationData, OperationEsdtPayment, Oper
 const CALLBACK_GAS: GasLimit = 10_000_000; // Increase if not enough
 const TRANSACTION_GAS: GasLimit = 30_000_000;
 const WEGLD_ID: &str = "WEGLD-bd4d79";
+const DEFAULT_ISSUE_COST: u64 = 50000000000000000;
 
 #[multiversx_sc::module]
 pub trait TransferTokensModule:
@@ -49,6 +50,20 @@ pub trait TransferTokensModule:
 
     //TODO: register_token payable endpoint
     // require x amount wegld
+    #[endpoint(registerTokens)]
+    #[payable("*")]
+    fn register_tokens(&self, tokens: MultiValueEncoded<TokenIdentifier>) {
+        let call_payment = self.call_value().single_esdt().clone();
+
+        require!(
+            call_payment.amount == DEFAULT_ISSUE_COST * tokens.len() as u64,
+            "WEGLD fee amount is not met"
+        );
+
+        for token in tokens {
+            self.paid_issued_tokens().insert(token);
+        }
+    }
 
     fn mint_tokens(
         &self,

From 3f5de49eb451dce398669270813c57ab9b019a9f Mon Sep 17 00:00:00 2001
From: Andrei Baltariu <andreibaltariu1304@gmail.com>
Date: Fri, 28 Jun 2024 14:06:55 +0300
Subject: [PATCH 12/76] Modified wegld minting logic

---
 .../src/from_sovereign/transfer_tokens.rs     | 27 ++++++++++---------
 1 file changed, 15 insertions(+), 12 deletions(-)

diff --git a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
index 570af898..3e9fa795 100644
--- a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
+++ b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
@@ -74,7 +74,9 @@ pub trait TransferTokensModule:
         let mut wegld_amount = BigUint::from(0u32);
 
         for operation_token in operation_tokens.iter() {
-            if self.is_wegld_identifier(&operation_token.token_identifier) {
+            // add amount of transferred WEGLD
+            if self.is_wegld(&operation_token.token_identifier) {
+                wegld_amount += &operation_token.token_data.amount;
                 continue;
             }
 
@@ -85,13 +87,12 @@ pub trait TransferTokensModule:
                 continue;
             }
 
-            // TODO: check storage + subtract 0.05 WEGLD
-
             if self.was_token_minted(&operation_token.token_identifier) {
                 continue;
             }
 
-            wegld_amount += &operation_token.token_data.amount;
+            // subtract the issue cost
+            wegld_amount -= BigUint::from(DEFAULT_ISSUE_COST);
 
             let mut nonce = operation_token.token_nonce;
             if nonce == 0 {
@@ -147,14 +148,16 @@ pub trait TransferTokensModule:
             });
         }
 
-        let sc_address = self.blockchain().get_sc_address();
-        let payment = EsdtTokenPayment::new(WEGLD_ID.into(), 0, wegld_amount);
+        if wegld_amount > 0 {
+            let sc_address = self.blockchain().get_sc_address();
+            let payment = EsdtTokenPayment::new(WEGLD_ID.into(), 0, wegld_amount);
 
-        self.tx()
-            .from(sc_address)
-            .to(sender)
-            .esdt(payment)
-            .transfer();
+            self.tx()
+                .from(sc_address)
+                .to(sender)
+                .esdt(payment)
+                .transfer();
+        }
 
         output_payments
     }
@@ -319,7 +322,7 @@ pub trait TransferTokensModule:
     }
 
     #[inline]
-    fn is_wegld_identifier(&self, token_id: &TokenIdentifier<Self::Api>) -> bool {
+    fn is_wegld(&self, token_id: &TokenIdentifier<Self::Api>) -> bool {
         token_id.eq(&TokenIdentifier::from(WEGLD_ID))
     }
 

From 752673e0fc2cc871f42f64935262406d724f19a9 Mon Sep 17 00:00:00 2001
From: Andrei Baltariu <andreibaltariu1304@gmail.com>
Date: Fri, 28 Jun 2024 14:29:28 +0300
Subject: [PATCH 13/76] Added wegld require for register tokens endpoint

---
 enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
index 3e9fa795..ae8b84dd 100644
--- a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
+++ b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
@@ -55,6 +55,11 @@ pub trait TransferTokensModule:
     fn register_tokens(&self, tokens: MultiValueEncoded<TokenIdentifier>) {
         let call_payment = self.call_value().single_esdt().clone();
 
+        require!(
+            call_payment.token_identifier == TokenIdentifier::from(WEGLD_ID),
+            "WEGLD is the only token accepted as register fee"
+        );
+
         require!(
             call_payment.amount == DEFAULT_ISSUE_COST * tokens.len() as u64,
             "WEGLD fee amount is not met"

From 43e896c2a3fd7151cc6bd89f55a70e4d854f84aa Mon Sep 17 00:00:00 2001
From: Andrei Baltariu <andreibaltariu1304@gmail.com>
Date: Fri, 28 Jun 2024 15:48:43 +0300
Subject: [PATCH 14/76] Added wegld fee functions + reverted mint_tokens

---
 .../src/from_sovereign/transfer_tokens.rs     | 74 +++++++++++--------
 1 file changed, 42 insertions(+), 32 deletions(-)

diff --git a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
index ae8b84dd..c9c004d2 100644
--- a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
+++ b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
@@ -38,8 +38,7 @@ pub trait TransferTokensModule:
             sc_panic!("Operation is not registered");
         }
 
-        let minted_operation_tokens =
-            self.mint_tokens(&operation.data.op_sender, &operation.tokens);
+        let minted_operation_tokens = self.mint_tokens(&operation.tokens);
         let operation_tuple = OperationTuple {
             op_hash: operation_hash,
             operation,
@@ -70,35 +69,58 @@ pub trait TransferTokensModule:
         }
     }
 
+    fn calculate_wegld_fee(
+        &self,
+        tokens: ManagedVec<OperationEsdtPayment<Self::Api>>,
+    ) -> ManagedVec<OperationEsdtPayment<Self::Api>> {
+        if tokens.len() == 1 {
+            return tokens;
+        }
+
+        let wegld_payment = tokens.get(0);
+
+        let mut checked_tokens = tokens.clone();
+        let initial_wegld_amount = wegld_payment.token_data.amount;
+        let mut wegld_amount = initial_wegld_amount.clone();
+
+        checked_tokens.remove(0);
+
+        for token in checked_tokens.iter() {
+            if !self.was_token_minted(&token.token_identifier) {
+                wegld_amount -= token.token_data.amount;
+            }
+        }
+
+        if wegld_amount == initial_wegld_amount {
+            return tokens;
+        }
+
+        checked_tokens
+    }
+
+    fn sendback_wegld(&self, sender: &ManagedAddress<Self::Api>, wegld_amount: BigUint<Self::Api>) {
+        let sc_address = self.blockchain().get_sc_address();
+        let payment = EsdtTokenPayment::new(WEGLD_ID.into(), 0, wegld_amount);
+
+        self.tx()
+            .from(sc_address)
+            .to(sender)
+            .esdt(payment)
+            .transfer();
+    }
+
     fn mint_tokens(
         &self,
-        sender: &ManagedAddress<Self::Api>,
         operation_tokens: &ManagedVec<OperationEsdtPayment<Self::Api>>,
     ) -> ManagedVec<OperationEsdtPayment<Self::Api>> {
         let mut output_payments = ManagedVec::new();
-        let mut wegld_amount = BigUint::from(0u32);
 
         for operation_token in operation_tokens.iter() {
-            // add amount of transferred WEGLD
-            if self.is_wegld(&operation_token.token_identifier) {
-                wegld_amount += &operation_token.token_data.amount;
-                continue;
-            }
-
-            let has_sov_token_prefix = self.has_sov_token_prefix(&operation_token.token_identifier);
-
-            if !has_sov_token_prefix {
+            if !self.has_sov_token_prefix(&operation_token.token_identifier) {
                 output_payments.push(operation_token.clone());
                 continue;
             }
 
-            if self.was_token_minted(&operation_token.token_identifier) {
-                continue;
-            }
-
-            // subtract the issue cost
-            wegld_amount -= BigUint::from(DEFAULT_ISSUE_COST);
-
             let mut nonce = operation_token.token_nonce;
             if nonce == 0 {
                 self.send().esdt_local_mint(
@@ -153,20 +175,8 @@ pub trait TransferTokensModule:
             });
         }
 
-        if wegld_amount > 0 {
-            let sc_address = self.blockchain().get_sc_address();
-            let payment = EsdtTokenPayment::new(WEGLD_ID.into(), 0, wegld_amount);
-
-            self.tx()
-                .from(sc_address)
-                .to(sender)
-                .esdt(payment)
-                .transfer();
-        }
-
         output_payments
     }
-
     fn distribute_payments(
         &self,
         hash_of_hashes: ManagedBuffer,

From a05a8293ef2c59d57c2e92bd5ffd6ddef92b977a Mon Sep 17 00:00:00 2001
From: Andrei Baltariu <andreibaltariu1304@gmail.com>
Date: Fri, 28 Jun 2024 15:58:45 +0300
Subject: [PATCH 15/76] Modified execute endpoint for wegld fee implementation

---
 .../src/from_sovereign/transfer_tokens.rs     | 28 +++++++++++--------
 1 file changed, 17 insertions(+), 11 deletions(-)

diff --git a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
index c9c004d2..7cbf57d4 100644
--- a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
+++ b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
@@ -38,12 +38,16 @@ pub trait TransferTokensModule:
             sc_panic!("Operation is not registered");
         }
 
-        let minted_operation_tokens = self.mint_tokens(&operation.tokens);
+        let (wegld_amount, checked_tokens) = self.calculate_wegld_fee(&operation.tokens);
+
+        let minted_operation_tokens = self.mint_tokens(&checked_tokens);
         let operation_tuple = OperationTuple {
             op_hash: operation_hash,
-            operation,
+            operation: operation.clone(),
         };
 
+        self.refund_wegld(&operation.data.op_sender, wegld_amount);
+
         self.distribute_payments(hash_of_hashes, operation_tuple, minted_operation_tokens);
     }
 
@@ -71,16 +75,18 @@ pub trait TransferTokensModule:
 
     fn calculate_wegld_fee(
         &self,
-        tokens: ManagedVec<OperationEsdtPayment<Self::Api>>,
-    ) -> ManagedVec<OperationEsdtPayment<Self::Api>> {
+        tokens: &ManagedVec<OperationEsdtPayment<Self::Api>>,
+    ) -> (
+        BigUint<Self::Api>,
+        ManagedVec<OperationEsdtPayment<Self::Api>>,
+    ) {
+        let wegld_payment = tokens.get(0);
         if tokens.len() == 1 {
-            return tokens;
+            return (wegld_payment.token_data.amount, tokens.clone());
         }
 
-        let wegld_payment = tokens.get(0);
-
         let mut checked_tokens = tokens.clone();
-        let initial_wegld_amount = wegld_payment.token_data.amount;
+        let initial_wegld_amount = wegld_payment.token_data.amount.clone();
         let mut wegld_amount = initial_wegld_amount.clone();
 
         checked_tokens.remove(0);
@@ -92,13 +98,13 @@ pub trait TransferTokensModule:
         }
 
         if wegld_amount == initial_wegld_amount {
-            return tokens;
+            return (wegld_payment.token_data.amount, tokens.clone());
         }
 
-        checked_tokens
+        (wegld_amount, checked_tokens)
     }
 
-    fn sendback_wegld(&self, sender: &ManagedAddress<Self::Api>, wegld_amount: BigUint<Self::Api>) {
+    fn refund_wegld(&self, sender: &ManagedAddress<Self::Api>, wegld_amount: BigUint<Self::Api>) {
         let sc_address = self.blockchain().get_sc_address();
         let payment = EsdtTokenPayment::new(WEGLD_ID.into(), 0, wegld_amount);
 

From 1a77a326395232c1ee3be181e2f0c0716283d8d6 Mon Sep 17 00:00:00 2001
From: Andrei Baltariu <andreibaltariu1304@gmail.com>
Date: Fri, 28 Jun 2024 15:59:57 +0300
Subject: [PATCH 16/76] Regenerated proxy

---
 enshrine-esdt-safe/src/enshrine_esdt_safe_proxy.rs   | 12 ++++++++++++
 .../wasm-enshrine-esdt-safe-full/src/lib.rs          |  5 +++--
 enshrine-esdt-safe/wasm/src/lib.rs                   |  5 +++--
 3 files changed, 18 insertions(+), 4 deletions(-)

diff --git a/enshrine-esdt-safe/src/enshrine_esdt_safe_proxy.rs b/enshrine-esdt-safe/src/enshrine_esdt_safe_proxy.rs
index bab658db..dc562369 100644
--- a/enshrine-esdt-safe/src/enshrine_esdt_safe_proxy.rs
+++ b/enshrine-esdt-safe/src/enshrine_esdt_safe_proxy.rs
@@ -181,6 +181,18 @@ where
             .original_result()
     }
 
+    pub fn register_tokens<
+        Arg0: ProxyArg<MultiValueEncoded<Env::Api, TokenIdentifier<Env::Api>>>,
+    >(
+        self,
+        tokens: Arg0,
+    ) -> TxTypedCall<Env, From, To, (), Gas, ()> {
+        self.wrapped_tx
+            .raw_call("registerTokens")
+            .argument(&tokens)
+            .original_result()
+    }
+
     pub fn set_max_tx_batch_size<
         Arg0: ProxyArg<usize>,
     >(
diff --git a/enshrine-esdt-safe/wasm-enshrine-esdt-safe-full/src/lib.rs b/enshrine-esdt-safe/wasm-enshrine-esdt-safe-full/src/lib.rs
index 2c4ffaed..08014062 100644
--- a/enshrine-esdt-safe/wasm-enshrine-esdt-safe-full/src/lib.rs
+++ b/enshrine-esdt-safe/wasm-enshrine-esdt-safe-full/src/lib.rs
@@ -6,10 +6,10 @@
 
 // Init:                                 1
 // Upgrade:                              1
-// Endpoints:                           27
+// Endpoints:                           28
 // Async Callback:                       1
 // Promise callbacks:                    1
-// Total number of exported functions:  31
+// Total number of exported functions:  32
 
 #![no_std]
 
@@ -28,6 +28,7 @@ multiversx_sc_wasm_adapter::endpoints! {
         addSigners => add_signers
         removeSigners => remove_signers
         executeBridgeOps => execute_operations
+        registerTokens => register_tokens
         setMaxTxBatchSize => set_max_tx_batch_size
         setMaxTxBatchBlockDuration => set_max_tx_batch_block_duration
         getCurrentTxBatch => get_current_tx_batch
diff --git a/enshrine-esdt-safe/wasm/src/lib.rs b/enshrine-esdt-safe/wasm/src/lib.rs
index 2c4ffaed..08014062 100644
--- a/enshrine-esdt-safe/wasm/src/lib.rs
+++ b/enshrine-esdt-safe/wasm/src/lib.rs
@@ -6,10 +6,10 @@
 
 // Init:                                 1
 // Upgrade:                              1
-// Endpoints:                           27
+// Endpoints:                           28
 // Async Callback:                       1
 // Promise callbacks:                    1
-// Total number of exported functions:  31
+// Total number of exported functions:  32
 
 #![no_std]
 
@@ -28,6 +28,7 @@ multiversx_sc_wasm_adapter::endpoints! {
         addSigners => add_signers
         removeSigners => remove_signers
         executeBridgeOps => execute_operations
+        registerTokens => register_tokens
         setMaxTxBatchSize => set_max_tx_batch_size
         setMaxTxBatchBlockDuration => set_max_tx_batch_block_duration
         getCurrentTxBatch => get_current_tx_batch

From 139528f9dd972ea9202143f789983e65c38a7a15 Mon Sep 17 00:00:00 2001
From: Andrei Baltariu <andreibaltariu1304@gmail.com>
Date: Mon, 1 Jul 2024 11:40:50 +0300
Subject: [PATCH 17/76] Removed from() in refund_wegld function

---
 enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs | 7 +------
 1 file changed, 1 insertion(+), 6 deletions(-)

diff --git a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
index 7cbf57d4..b16348a0 100644
--- a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
+++ b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
@@ -105,14 +105,9 @@ pub trait TransferTokensModule:
     }
 
     fn refund_wegld(&self, sender: &ManagedAddress<Self::Api>, wegld_amount: BigUint<Self::Api>) {
-        let sc_address = self.blockchain().get_sc_address();
         let payment = EsdtTokenPayment::new(WEGLD_ID.into(), 0, wegld_amount);
 
-        self.tx()
-            .from(sc_address)
-            .to(sender)
-            .esdt(payment)
-            .transfer();
+        self.tx().to(sender).esdt(payment).transfer();
     }
 
     fn mint_tokens(

From 4a9db9fa7255537c9427101dcd01eef175b3e9d9 Mon Sep 17 00:00:00 2001
From: Andrei Baltariu <andreibaltariu1304@gmail.com>
Date: Mon, 1 Jul 2024 11:55:38 +0300
Subject: [PATCH 18/76] Added wegld_ticker storage mapper

---
 enshrine-esdt-safe/src/common/storage.rs | 3 +++
 enshrine-esdt-safe/src/lib.rs            | 6 ++++++
 2 files changed, 9 insertions(+)

diff --git a/enshrine-esdt-safe/src/common/storage.rs b/enshrine-esdt-safe/src/common/storage.rs
index c17ff108..b1e60e04 100644
--- a/enshrine-esdt-safe/src/common/storage.rs
+++ b/enshrine-esdt-safe/src/common/storage.rs
@@ -4,4 +4,7 @@ use multiversx_sc::imports::*;
 pub trait CommonStorage {
     #[storage_mapper("isSovereignChain")]
     fn is_sovereign_chain(&self) -> SingleValueMapper<bool>;
+
+    #[storage_mapper("wegldTicker")]
+    fn wegld_ticker(&self) -> SingleValueMapper<ManagedBuffer>;
 }
diff --git a/enshrine-esdt-safe/src/lib.rs b/enshrine-esdt-safe/src/lib.rs
index 260e0159..2a8034d7 100644
--- a/enshrine-esdt-safe/src/lib.rs
+++ b/enshrine-esdt-safe/src/lib.rs
@@ -45,6 +45,12 @@ pub trait EnshrineEsdtSafe:
         self.header_verifier_address().set(&header_verifier_address);
     }
 
+    #[only_owner]
+    #[endpoint(setWegldTicker)]
+    fn set_wegld_ticker(&self, wegld_ticker: ManagedBuffer) {
+        self.wegld_ticker().set(wegld_ticker);
+    }
+
     #[upgrade]
     fn upgrade(&self) {}
 }

From fd7ece4b1957dc6324e019f8ea92b82446a828aa Mon Sep 17 00:00:00 2001
From: Andrei Baltariu <andreibaltariu1304@gmail.com>
Date: Mon, 1 Jul 2024 11:57:51 +0300
Subject: [PATCH 19/76] Modified wegld mapper to save TokenIdentifier

---
 enshrine-esdt-safe/src/common/storage.rs | 2 +-
 enshrine-esdt-safe/src/lib.rs            | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/enshrine-esdt-safe/src/common/storage.rs b/enshrine-esdt-safe/src/common/storage.rs
index b1e60e04..30abc29c 100644
--- a/enshrine-esdt-safe/src/common/storage.rs
+++ b/enshrine-esdt-safe/src/common/storage.rs
@@ -6,5 +6,5 @@ pub trait CommonStorage {
     fn is_sovereign_chain(&self) -> SingleValueMapper<bool>;
 
     #[storage_mapper("wegldTicker")]
-    fn wegld_ticker(&self) -> SingleValueMapper<ManagedBuffer>;
+    fn wegld_ticker(&self) -> SingleValueMapper<TokenIdentifier>;
 }
diff --git a/enshrine-esdt-safe/src/lib.rs b/enshrine-esdt-safe/src/lib.rs
index 2a8034d7..25300ccd 100644
--- a/enshrine-esdt-safe/src/lib.rs
+++ b/enshrine-esdt-safe/src/lib.rs
@@ -48,7 +48,7 @@ pub trait EnshrineEsdtSafe:
     #[only_owner]
     #[endpoint(setWegldTicker)]
     fn set_wegld_ticker(&self, wegld_ticker: ManagedBuffer) {
-        self.wegld_ticker().set(wegld_ticker);
+        self.wegld_ticker().set(TokenIdentifier::from(wegld_ticker));
     }
 
     #[upgrade]

From 04431bffc95523063ff50a86e0cba0d95e643181 Mon Sep 17 00:00:00 2001
From: Andrei Baltariu <andreibaltariu1304@gmail.com>
Date: Mon, 1 Jul 2024 12:53:36 +0300
Subject: [PATCH 20/76] Renamed wegld mapper

---
 enshrine-esdt-safe/src/common/storage.rs                 | 2 +-
 enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs | 3 ++-
 enshrine-esdt-safe/src/lib.rs                            | 3 ++-
 3 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/enshrine-esdt-safe/src/common/storage.rs b/enshrine-esdt-safe/src/common/storage.rs
index 30abc29c..0c29794d 100644
--- a/enshrine-esdt-safe/src/common/storage.rs
+++ b/enshrine-esdt-safe/src/common/storage.rs
@@ -6,5 +6,5 @@ pub trait CommonStorage {
     fn is_sovereign_chain(&self) -> SingleValueMapper<bool>;
 
     #[storage_mapper("wegldTicker")]
-    fn wegld_ticker(&self) -> SingleValueMapper<TokenIdentifier>;
+    fn wegld_identifier(&self) -> SingleValueMapper<TokenIdentifier>;
 }
diff --git a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
index b16348a0..6200d5e7 100644
--- a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
+++ b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
@@ -339,7 +339,8 @@ pub trait TransferTokensModule:
 
     #[inline]
     fn is_wegld(&self, token_id: &TokenIdentifier<Self::Api>) -> bool {
-        token_id.eq(&TokenIdentifier::from(WEGLD_ID))
+        let wegld_identifier = self.wegld_identifier().get();
+        token_id.eq(&wegld_identifier)
     }
 
     #[storage_mapper("pending_hashes")]
diff --git a/enshrine-esdt-safe/src/lib.rs b/enshrine-esdt-safe/src/lib.rs
index 25300ccd..ceac4fee 100644
--- a/enshrine-esdt-safe/src/lib.rs
+++ b/enshrine-esdt-safe/src/lib.rs
@@ -48,7 +48,8 @@ pub trait EnshrineEsdtSafe:
     #[only_owner]
     #[endpoint(setWegldTicker)]
     fn set_wegld_ticker(&self, wegld_ticker: ManagedBuffer) {
-        self.wegld_ticker().set(TokenIdentifier::from(wegld_ticker));
+        self.wegld_identifier()
+            .set(TokenIdentifier::from(wegld_ticker));
     }
 
     #[upgrade]

From a9bdc9f75313ee62995b2a99480134d225cc1986 Mon Sep 17 00:00:00 2001
From: Andrei Baltariu <andreibaltariu1304@gmail.com>
Date: Mon, 1 Jul 2024 12:55:40 +0300
Subject: [PATCH 21/76] Removed any use of wegld identifier constant

---
 enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
index 6200d5e7..f6c07195 100644
--- a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
+++ b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
@@ -7,7 +7,6 @@ use transaction::{GasLimit, Operation, OperationData, OperationEsdtPayment, Oper
 
 const CALLBACK_GAS: GasLimit = 10_000_000; // Increase if not enough
 const TRANSACTION_GAS: GasLimit = 30_000_000;
-const WEGLD_ID: &str = "WEGLD-bd4d79";
 const DEFAULT_ISSUE_COST: u64 = 50000000000000000;
 
 #[multiversx_sc::module]
@@ -57,9 +56,10 @@ pub trait TransferTokensModule:
     #[payable("*")]
     fn register_tokens(&self, tokens: MultiValueEncoded<TokenIdentifier>) {
         let call_payment = self.call_value().single_esdt().clone();
+        let wegld_identifier = self.wegld_identifier().get();
 
         require!(
-            call_payment.token_identifier == TokenIdentifier::from(WEGLD_ID),
+            call_payment.token_identifier == wegld_identifier,
             "WEGLD is the only token accepted as register fee"
         );
 
@@ -105,7 +105,8 @@ pub trait TransferTokensModule:
     }
 
     fn refund_wegld(&self, sender: &ManagedAddress<Self::Api>, wegld_amount: BigUint<Self::Api>) {
-        let payment = EsdtTokenPayment::new(WEGLD_ID.into(), 0, wegld_amount);
+        let wegld_identifier = self.wegld_identifier().get();
+        let payment = EsdtTokenPayment::new(wegld_identifier, 0, wegld_amount);
 
         self.tx().to(sender).esdt(payment).transfer();
     }

From d8124c252b05adcc57f20b8f07fad79d4c0ccaa9 Mon Sep 17 00:00:00 2001
From: Andrei Baltariu <andreibaltariu1304@gmail.com>
Date: Mon, 1 Jul 2024 13:23:40 +0300
Subject: [PATCH 22/76] Regenerated enshrine proxy

---
 enshrine-esdt-safe/src/enshrine_esdt_safe_proxy.rs  | 13 +++++++++++++
 .../wasm-enshrine-esdt-safe-full/src/lib.rs         |  5 +++--
 enshrine-esdt-safe/wasm/src/lib.rs                  |  5 +++--
 3 files changed, 19 insertions(+), 4 deletions(-)

diff --git a/enshrine-esdt-safe/src/enshrine_esdt_safe_proxy.rs b/enshrine-esdt-safe/src/enshrine_esdt_safe_proxy.rs
index dc562369..d4ba8092 100644
--- a/enshrine-esdt-safe/src/enshrine_esdt_safe_proxy.rs
+++ b/enshrine-esdt-safe/src/enshrine_esdt_safe_proxy.rs
@@ -111,6 +111,19 @@ where
             .original_result()
     }
 
+    pub fn set_wegld_ticker<
+        Arg0: ProxyArg<ManagedBuffer<Env::Api>>,
+    >(
+        self,
+        wegld_ticker: Arg0,
+    ) -> TxTypedCall<Env, From, To, NotPayable, Gas, ()> {
+        self.wrapped_tx
+            .payment(NotPayable)
+            .raw_call("setWegldTicker")
+            .argument(&wegld_ticker)
+            .original_result()
+    }
+
     pub fn deposit<
         Arg0: ProxyArg<ManagedAddress<Env::Api>>,
         Arg1: ProxyArg<OptionalValue<MultiValue3<u64, ManagedBuffer<Env::Api>, ManagedVec<Env::Api, ManagedBuffer<Env::Api>>>>>,
diff --git a/enshrine-esdt-safe/wasm-enshrine-esdt-safe-full/src/lib.rs b/enshrine-esdt-safe/wasm-enshrine-esdt-safe-full/src/lib.rs
index 08014062..ab0809b6 100644
--- a/enshrine-esdt-safe/wasm-enshrine-esdt-safe-full/src/lib.rs
+++ b/enshrine-esdt-safe/wasm-enshrine-esdt-safe-full/src/lib.rs
@@ -6,10 +6,10 @@
 
 // Init:                                 1
 // Upgrade:                              1
-// Endpoints:                           28
+// Endpoints:                           29
 // Async Callback:                       1
 // Promise callbacks:                    1
-// Total number of exported functions:  32
+// Total number of exported functions:  33
 
 #![no_std]
 
@@ -23,6 +23,7 @@ multiversx_sc_wasm_adapter::endpoints! {
         upgrade => upgrade
         setFeeMarketAddress => set_fee_market_address
         setHeaderVerifierAddress => set_header_verifier_address
+        setWegldTicker => set_wegld_ticker
         deposit => deposit
         setMinValidSigners => set_min_valid_signers
         addSigners => add_signers
diff --git a/enshrine-esdt-safe/wasm/src/lib.rs b/enshrine-esdt-safe/wasm/src/lib.rs
index 08014062..ab0809b6 100644
--- a/enshrine-esdt-safe/wasm/src/lib.rs
+++ b/enshrine-esdt-safe/wasm/src/lib.rs
@@ -6,10 +6,10 @@
 
 // Init:                                 1
 // Upgrade:                              1
-// Endpoints:                           28
+// Endpoints:                           29
 // Async Callback:                       1
 // Promise callbacks:                    1
-// Total number of exported functions:  32
+// Total number of exported functions:  33
 
 #![no_std]
 
@@ -23,6 +23,7 @@ multiversx_sc_wasm_adapter::endpoints! {
         upgrade => upgrade
         setFeeMarketAddress => set_fee_market_address
         setHeaderVerifierAddress => set_header_verifier_address
+        setWegldTicker => set_wegld_ticker
         deposit => deposit
         setMinValidSigners => set_min_valid_signers
         addSigners => add_signers

From 79add8fae4f10101239ce45d6c586d5eab95bd45 Mon Sep 17 00:00:00 2001
From: Andrei Baltariu <andreibaltariu1304@gmail.com>
Date: Mon, 1 Jul 2024 15:06:28 +0300
Subject: [PATCH 23/76] Renamed wegld method and modified logic

---
 .../src/from_sovereign/transfer_tokens.rs     | 31 ++++++++++++-------
 1 file changed, 19 insertions(+), 12 deletions(-)

diff --git a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
index f6c07195..854924d5 100644
--- a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
+++ b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
@@ -37,7 +37,8 @@ pub trait TransferTokensModule:
             sc_panic!("Operation is not registered");
         }
 
-        let (wegld_amount, checked_tokens) = self.calculate_wegld_fee(&operation.tokens);
+        let (wegld_amount, checked_tokens) =
+            self.check_tokens_for_wegld_fee(operation.tokens.clone());
 
         let minted_operation_tokens = self.mint_tokens(&checked_tokens);
         let operation_tuple = OperationTuple {
@@ -73,32 +74,33 @@ pub trait TransferTokensModule:
         }
     }
 
-    fn calculate_wegld_fee(
+    fn check_tokens_for_wegld_fee(
         &self,
-        tokens: &ManagedVec<OperationEsdtPayment<Self::Api>>,
+        tokens: ManagedVec<OperationEsdtPayment<Self::Api>>,
     ) -> (
         BigUint<Self::Api>,
         ManagedVec<OperationEsdtPayment<Self::Api>>,
     ) {
         let wegld_payment = tokens.get(0);
-        if tokens.len() == 1 {
-            return (wegld_payment.token_data.amount, tokens.clone());
+        let mut checked_tokens = tokens.clone();
+
+        if checked_tokens.len() == 1 {
+            return (wegld_payment.token_data.amount, checked_tokens);
         }
 
-        let mut checked_tokens = tokens.clone();
-        let initial_wegld_amount = wegld_payment.token_data.amount.clone();
-        let mut wegld_amount = initial_wegld_amount.clone();
+        let mut wegld_amount = wegld_payment.token_data.amount.clone();
 
         checked_tokens.remove(0);
 
         for token in checked_tokens.iter() {
-            if !self.was_token_minted(&token.token_identifier) {
+            if !self.was_token_registered(&token.token_identifier) {
                 wegld_amount -= token.token_data.amount;
+                self.register_token(token.token_identifier);
             }
         }
 
-        if wegld_amount == initial_wegld_amount {
-            return (wegld_payment.token_data.amount, tokens.clone());
+        if wegld_amount == wegld_payment.token_data.amount {
+            return (wegld_amount, tokens);
         }
 
         (wegld_amount, checked_tokens)
@@ -334,10 +336,15 @@ pub trait TransferTokensModule:
     }
 
     #[inline]
-    fn was_token_minted(&self, token_id: &TokenIdentifier<Self::Api>) -> bool {
+    fn was_token_registered(&self, token_id: &TokenIdentifier<Self::Api>) -> bool {
         self.paid_issued_tokens().contains(token_id)
     }
 
+    #[inline]
+    fn register_token(&self, token_id: TokenIdentifier<Self::Api>) {
+        self.paid_issued_tokens().insert(token_id);
+    }
+
     #[inline]
     fn is_wegld(&self, token_id: &TokenIdentifier<Self::Api>) -> bool {
         let wegld_identifier = self.wegld_identifier().get();

From 12d9950d7f33000884b8525958d7d5f5e915d360 Mon Sep 17 00:00:00 2001
From: Andrei Baltariu <andreibaltariu1304@gmail.com>
Date: Tue, 2 Jul 2024 12:28:02 +0300
Subject: [PATCH 24/76] Fixed comments

---
 enshrine-esdt-safe/src/common/storage.rs               |  2 +-
 .../src/from_sovereign/transfer_tokens.rs              | 10 +++++-----
 enshrine-esdt-safe/src/lib.rs                          |  7 +++++++
 3 files changed, 13 insertions(+), 6 deletions(-)

diff --git a/enshrine-esdt-safe/src/common/storage.rs b/enshrine-esdt-safe/src/common/storage.rs
index 0c29794d..3857e6a1 100644
--- a/enshrine-esdt-safe/src/common/storage.rs
+++ b/enshrine-esdt-safe/src/common/storage.rs
@@ -5,6 +5,6 @@ pub trait CommonStorage {
     #[storage_mapper("isSovereignChain")]
     fn is_sovereign_chain(&self) -> SingleValueMapper<bool>;
 
-    #[storage_mapper("wegldTicker")]
+    #[storage_mapper("wegldIdentifier")]
     fn wegld_identifier(&self) -> SingleValueMapper<TokenIdentifier>;
 }
diff --git a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
index 854924d5..2cff837a 100644
--- a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
+++ b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
@@ -23,8 +23,10 @@ pub trait TransferTokensModule:
 {
     #[endpoint(executeBridgeOps)]
     fn execute_operations(&self, hash_of_hashes: ManagedBuffer, operation: Operation<Self::Api>) {
+        let is_sovereign_chain = self.is_sovereign_chain().get();
+
         require!(
-            !self.is_sovereign_chain().get(),
+            !is_sovereign_chain,
             "Invalid method to call in current chain"
         );
 
@@ -51,8 +53,6 @@ pub trait TransferTokensModule:
         self.distribute_payments(hash_of_hashes, operation_tuple, minted_operation_tokens);
     }
 
-    //TODO: register_token payable endpoint
-    // require x amount wegld
     #[endpoint(registerTokens)]
     #[payable("*")]
     fn register_tokens(&self, tokens: MultiValueEncoded<TokenIdentifier>) {
@@ -69,8 +69,8 @@ pub trait TransferTokensModule:
             "WEGLD fee amount is not met"
         );
 
-        for token in tokens {
-            self.paid_issued_tokens().insert(token);
+        for token_id in tokens {
+            self.register_token(token_id);
         }
     }
 
diff --git a/enshrine-esdt-safe/src/lib.rs b/enshrine-esdt-safe/src/lib.rs
index ceac4fee..b8bf4b8e 100644
--- a/enshrine-esdt-safe/src/lib.rs
+++ b/enshrine-esdt-safe/src/lib.rs
@@ -48,6 +48,13 @@ pub trait EnshrineEsdtSafe:
     #[only_owner]
     #[endpoint(setWegldTicker)]
     fn set_wegld_ticker(&self, wegld_ticker: ManagedBuffer) {
+        let is_sovereign_chain = self.is_sovereign_chain().get();
+
+        require!(
+            is_sovereign_chain == true,
+            "WEGLD Identifier can be set only on Mainchain"
+        );
+
         self.wegld_identifier()
             .set(TokenIdentifier::from(wegld_ticker));
     }

From 51f855f1bcaa114988d8d8ee0bc0fa9c7602645b Mon Sep 17 00:00:00 2001
From: Andrei Baltariu <andreibaltariu1304@gmail.com>
Date: Tue, 2 Jul 2024 13:58:01 +0300
Subject: [PATCH 25/76] Modified check for wegld fee function

---
 .../src/from_sovereign/transfer_tokens.rs     | 39 +++++++++++++------
 1 file changed, 27 insertions(+), 12 deletions(-)

diff --git a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
index 2cff837a..e9dab0df 100644
--- a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
+++ b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
@@ -42,14 +42,14 @@ pub trait TransferTokensModule:
         let (wegld_amount, checked_tokens) =
             self.check_tokens_for_wegld_fee(operation.tokens.clone());
 
+        self.refund_wegld(&operation.data.op_sender, wegld_amount);
+
         let minted_operation_tokens = self.mint_tokens(&checked_tokens);
         let operation_tuple = OperationTuple {
             op_hash: operation_hash,
             operation: operation.clone(),
         };
 
-        self.refund_wegld(&operation.data.op_sender, wegld_amount);
-
         self.distribute_payments(hash_of_hashes, operation_tuple, minted_operation_tokens);
     }
 
@@ -81,29 +81,44 @@ pub trait TransferTokensModule:
         BigUint<Self::Api>,
         ManagedVec<OperationEsdtPayment<Self::Api>>,
     ) {
-        let wegld_payment = tokens.get(0);
-        let mut checked_tokens = tokens.clone();
+        let biguint_zero = BigUint::from(0u32);
+        let first_payment = tokens.get(0);
+        let is_first_payment_wegld = self.is_wegld(&first_payment.token_identifier);
+
+        if !is_first_payment_wegld {
+            for token in tokens.iter() {
+                if !self.was_token_registered(&token.token_identifier)
+                    || self.has_sov_token_prefix(&token.token_identifier)
+                {
+                    return (biguint_zero, ManagedVec::new());
+                }
+            }
+        }
 
-        if checked_tokens.len() == 1 {
-            return (wegld_payment.token_data.amount, checked_tokens);
+        if is_first_payment_wegld && tokens.len() == 1 {
+            return (biguint_zero, tokens);
         }
 
-        let mut wegld_amount = wegld_payment.token_data.amount.clone();
+        let mut remaining_tokens = tokens.clone();
+        let mut wegld_amount = first_payment.token_data.amount.clone();
+        let mut unregistered_tokens_count = 0;
 
-        checked_tokens.remove(0);
+        remaining_tokens.remove(0);
 
-        for token in checked_tokens.iter() {
+        for token in remaining_tokens.iter() {
             if !self.was_token_registered(&token.token_identifier) {
-                wegld_amount -= token.token_data.amount;
+                unregistered_tokens_count += 1;
                 self.register_token(token.token_identifier);
             }
         }
 
-        if wegld_amount == wegld_payment.token_data.amount {
+        wegld_amount -= DEFAULT_ISSUE_COST * unregistered_tokens_count;
+
+        if first_payment.token_data.amount >= wegld_amount {
             return (wegld_amount, tokens);
         }
 
-        (wegld_amount, checked_tokens)
+        (biguint_zero, tokens)
     }
 
     fn refund_wegld(&self, sender: &ManagedAddress<Self::Api>, wegld_amount: BigUint<Self::Api>) {

From d691d0618e4b08c85f4dd591e962ce4c68b619de Mon Sep 17 00:00:00 2001
From: Andrei Baltariu <andreibaltariu1304@gmail.com>
Date: Tue, 2 Jul 2024 14:01:56 +0300
Subject: [PATCH 26/76] Modified execute_operation logic to throw event

---
 .../src/from_sovereign/transfer_tokens.rs     | 24 ++++++++++++-------
 1 file changed, 16 insertions(+), 8 deletions(-)

diff --git a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
index e9dab0df..a774e87d 100644
--- a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
+++ b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
@@ -39,18 +39,26 @@ pub trait TransferTokensModule:
             sc_panic!("Operation is not registered");
         }
 
-        let (wegld_amount, checked_tokens) =
+        let (wegld_amount, remaining_tokens) =
             self.check_tokens_for_wegld_fee(operation.tokens.clone());
 
-        self.refund_wegld(&operation.data.op_sender, wegld_amount);
+        if remaining_tokens.len() > 0 {
+            self.refund_wegld(&operation.data.op_sender, wegld_amount);
 
-        let minted_operation_tokens = self.mint_tokens(&checked_tokens);
-        let operation_tuple = OperationTuple {
-            op_hash: operation_hash,
-            operation: operation.clone(),
-        };
+            let minted_operation_tokens = self.mint_tokens(&remaining_tokens);
+            let operation_tuple = OperationTuple {
+                op_hash: operation_hash.clone(),
+                operation: operation.clone(),
+            };
 
-        self.distribute_payments(hash_of_hashes, operation_tuple, minted_operation_tokens);
+            self.distribute_payments(
+                hash_of_hashes.clone(),
+                operation_tuple,
+                minted_operation_tokens,
+            );
+        }
+
+        self.execute_bridge_operation_event(hash_of_hashes, operation_hash);
     }
 
     #[endpoint(registerTokens)]

From b82ac418ab1be16b3236c2025ed55e358124f00a Mon Sep 17 00:00:00 2001
From: Andrei Baltariu <andreibaltariu1304@gmail.com>
Date: Tue, 2 Jul 2024 14:04:16 +0300
Subject: [PATCH 27/76] Function rename

---
 enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
index a774e87d..f4f2f191 100644
--- a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
+++ b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
@@ -40,7 +40,7 @@ pub trait TransferTokensModule:
         }
 
         let (wegld_amount, remaining_tokens) =
-            self.check_tokens_for_wegld_fee(operation.tokens.clone());
+            self.verify_operation_tokens_for_issue_fee(operation.tokens.clone());
 
         if remaining_tokens.len() > 0 {
             self.refund_wegld(&operation.data.op_sender, wegld_amount);
@@ -82,7 +82,7 @@ pub trait TransferTokensModule:
         }
     }
 
-    fn check_tokens_for_wegld_fee(
+    fn verify_operation_tokens_for_issue_fee(
         &self,
         tokens: ManagedVec<OperationEsdtPayment<Self::Api>>,
     ) -> (

From 201397b111bd5dc767fc2a95df9e3eea69245daf Mon Sep 17 00:00:00 2001
From: Andrei Baltariu <andreibaltariu1304@gmail.com>
Date: Tue, 2 Jul 2024 14:29:22 +0300
Subject: [PATCH 28/76] Modified inline function

---
 enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
index f4f2f191..9b58040a 100644
--- a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
+++ b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
@@ -370,8 +370,7 @@ pub trait TransferTokensModule:
 
     #[inline]
     fn is_wegld(&self, token_id: &TokenIdentifier<Self::Api>) -> bool {
-        let wegld_identifier = self.wegld_identifier().get();
-        token_id.eq(&wegld_identifier)
+        token_id.eq(&self.wegld_identifier().get())
     }
 
     #[storage_mapper("pending_hashes")]

From 6d65426bec7f1a17fda38f29b4242951a405e57e Mon Sep 17 00:00:00 2001
From: Andrei Baltariu <andreibaltariu1304@gmail.com>
Date: Tue, 2 Jul 2024 14:58:23 +0300
Subject: [PATCH 29/76] Added refund logic to verify function

---
 .../src/from_sovereign/transfer_tokens.rs     | 24 +++++++++----------
 1 file changed, 11 insertions(+), 13 deletions(-)

diff --git a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
index 9b58040a..357471b2 100644
--- a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
+++ b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
@@ -39,12 +39,12 @@ pub trait TransferTokensModule:
             sc_panic!("Operation is not registered");
         }
 
-        let (wegld_amount, remaining_tokens) =
-            self.verify_operation_tokens_for_issue_fee(operation.tokens.clone());
+        let (wegld_amount, remaining_tokens) = self.verify_operation_tokens_for_issue_fee(
+            &operation.data.op_sender,
+            operation.tokens.clone(),
+        );
 
         if remaining_tokens.len() > 0 {
-            self.refund_wegld(&operation.data.op_sender, wegld_amount);
-
             let minted_operation_tokens = self.mint_tokens(&remaining_tokens);
             let operation_tuple = OperationTuple {
                 op_hash: operation_hash.clone(),
@@ -84,12 +84,9 @@ pub trait TransferTokensModule:
 
     fn verify_operation_tokens_for_issue_fee(
         &self,
+        sender: &ManagedAddress<Self::Api>,
         tokens: ManagedVec<OperationEsdtPayment<Self::Api>>,
-    ) -> (
-        BigUint<Self::Api>,
-        ManagedVec<OperationEsdtPayment<Self::Api>>,
-    ) {
-        let biguint_zero = BigUint::from(0u32);
+    ) -> ManagedVec<OperationEsdtPayment<Self::Api>> {
         let first_payment = tokens.get(0);
         let is_first_payment_wegld = self.is_wegld(&first_payment.token_identifier);
 
@@ -98,13 +95,13 @@ pub trait TransferTokensModule:
                 if !self.was_token_registered(&token.token_identifier)
                     || self.has_sov_token_prefix(&token.token_identifier)
                 {
-                    return (biguint_zero, ManagedVec::new());
+                    return ManagedVec::new();
                 }
             }
         }
 
         if is_first_payment_wegld && tokens.len() == 1 {
-            return (biguint_zero, tokens);
+            return tokens;
         }
 
         let mut remaining_tokens = tokens.clone();
@@ -123,10 +120,11 @@ pub trait TransferTokensModule:
         wegld_amount -= DEFAULT_ISSUE_COST * unregistered_tokens_count;
 
         if first_payment.token_data.amount >= wegld_amount {
-            return (wegld_amount, tokens);
+            self.refund_wegld(sender, wegld_amount.clone());
+            return tokens;
         }
 
-        (biguint_zero, tokens)
+        tokens
     }
 
     fn refund_wegld(&self, sender: &ManagedAddress<Self::Api>, wegld_amount: BigUint<Self::Api>) {

From 12e326cb223733e7238ac1863e03c9d2f3f1a14a Mon Sep 17 00:00:00 2001
From: Andrei Baltariu <andreibaltariu1304@gmail.com>
Date: Tue, 2 Jul 2024 15:30:11 +0300
Subject: [PATCH 30/76] Modified init and fixed build error

---
 .../src/from_sovereign/transfer_tokens.rs     |  2 +-
 enshrine-esdt-safe/src/lib.rs                 | 28 +++++++++----------
 2 files changed, 14 insertions(+), 16 deletions(-)

diff --git a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
index 357471b2..2157a0b0 100644
--- a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
+++ b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
@@ -39,7 +39,7 @@ pub trait TransferTokensModule:
             sc_panic!("Operation is not registered");
         }
 
-        let (wegld_amount, remaining_tokens) = self.verify_operation_tokens_for_issue_fee(
+        let remaining_tokens = self.verify_operation_tokens_for_issue_fee(
             &operation.data.op_sender,
             operation.tokens.clone(),
         );
diff --git a/enshrine-esdt-safe/src/lib.rs b/enshrine-esdt-safe/src/lib.rs
index b8bf4b8e..8713497e 100644
--- a/enshrine-esdt-safe/src/lib.rs
+++ b/enshrine-esdt-safe/src/lib.rs
@@ -24,9 +24,21 @@ pub trait EnshrineEsdtSafe:
     + common::storage::CommonStorage
 {
     #[init]
-    fn init(&self, is_sovereign_chain: bool) {
+    fn init(&self, is_sovereign_chain: bool, wegld_ticker: OptionalValue<ManagedBuffer>) {
         self.is_sovereign_chain().set(is_sovereign_chain);
         self.set_paused(true);
+
+        if !is_sovereign_chain {
+            match wegld_ticker {
+                OptionalValue::Some(ticker) => {
+                    let identifier = TokenIdentifier::from(ticker);
+                    if identifier.is_valid_esdt_identifier() {
+                        self.wegld_identifier().set(identifier);
+                    }
+                }
+                OptionalValue::None => sc_panic!("WEGLD identifier must be set in Mainchain"),
+            }
+        }
     }
 
     #[only_owner]
@@ -45,20 +57,6 @@ pub trait EnshrineEsdtSafe:
         self.header_verifier_address().set(&header_verifier_address);
     }
 
-    #[only_owner]
-    #[endpoint(setWegldTicker)]
-    fn set_wegld_ticker(&self, wegld_ticker: ManagedBuffer) {
-        let is_sovereign_chain = self.is_sovereign_chain().get();
-
-        require!(
-            is_sovereign_chain == true,
-            "WEGLD Identifier can be set only on Mainchain"
-        );
-
-        self.wegld_identifier()
-            .set(TokenIdentifier::from(wegld_ticker));
-    }
-
     #[upgrade]
     fn upgrade(&self) {}
 }

From 59c266557d537ea4127b99401f11c1f4c50dfa65 Mon Sep 17 00:00:00 2001
From: Andrei Baltariu <andreibaltariu1304@gmail.com>
Date: Tue, 2 Jul 2024 15:56:24 +0300
Subject: [PATCH 31/76] Modified called event and wegld function

---
 .../src/from_sovereign/transfer_tokens.rs     | 21 ++++++++++++-------
 1 file changed, 14 insertions(+), 7 deletions(-)

diff --git a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
index 2157a0b0..30a7b1b9 100644
--- a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
+++ b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
@@ -58,7 +58,13 @@ pub trait TransferTokensModule:
             );
         }
 
-        self.execute_bridge_operation_event(hash_of_hashes, operation_hash);
+        self.emit_transfer_failed_events(
+            &hash_of_hashes,
+            &OperationTuple {
+                op_hash: operation_hash,
+                operation,
+            },
+        );
     }
 
     #[endpoint(registerTokens)]
@@ -93,25 +99,26 @@ pub trait TransferTokensModule:
         if !is_first_payment_wegld {
             for token in tokens.iter() {
                 if !self.was_token_registered(&token.token_identifier)
-                    || self.has_sov_token_prefix(&token.token_identifier)
+                    && self.has_sov_token_prefix(&token.token_identifier)
                 {
                     return ManagedVec::new();
                 }
             }
+
+            return tokens;
         }
 
         if is_first_payment_wegld && tokens.len() == 1 {
             return tokens;
         }
 
-        let mut remaining_tokens = tokens.clone();
         let mut wegld_amount = first_payment.token_data.amount.clone();
         let mut unregistered_tokens_count = 0;
 
-        remaining_tokens.remove(0);
-
-        for token in remaining_tokens.iter() {
-            if !self.was_token_registered(&token.token_identifier) {
+        for token in tokens.iter().skip(1) {
+            if !self.was_token_registered(&token.token_identifier)
+                && self.has_sov_token_prefix(&token.token_identifier)
+            {
                 unregistered_tokens_count += 1;
                 self.register_token(token.token_identifier);
             }

From 6693b9a12cf1e18ee693d5e44fce741fb10f9923 Mon Sep 17 00:00:00 2001
From: Andrei Baltariu <andreibaltariu1304@gmail.com>
Date: Tue, 2 Jul 2024 15:58:07 +0300
Subject: [PATCH 32/76] Regenerated proxy

---
 .../src/enshrine_esdt_safe_proxy.rs              | 16 +++-------------
 .../wasm-enshrine-esdt-safe-full/src/lib.rs      |  5 ++---
 enshrine-esdt-safe/wasm/src/lib.rs               |  5 ++---
 3 files changed, 7 insertions(+), 19 deletions(-)

diff --git a/enshrine-esdt-safe/src/enshrine_esdt_safe_proxy.rs b/enshrine-esdt-safe/src/enshrine_esdt_safe_proxy.rs
index d4ba8092..ee0eca77 100644
--- a/enshrine-esdt-safe/src/enshrine_esdt_safe_proxy.rs
+++ b/enshrine-esdt-safe/src/enshrine_esdt_safe_proxy.rs
@@ -45,14 +45,17 @@ where
 {
     pub fn init<
         Arg0: ProxyArg<bool>,
+        Arg1: ProxyArg<OptionalValue<ManagedBuffer<Env::Api>>>,
     >(
         self,
         is_sovereign_chain: Arg0,
+        wegld_ticker: Arg1,
     ) -> TxTypedDeploy<Env, From, NotPayable, Gas, ()> {
         self.wrapped_tx
             .payment(NotPayable)
             .raw_deploy()
             .argument(&is_sovereign_chain)
+            .argument(&wegld_ticker)
             .original_result()
     }
 }
@@ -111,19 +114,6 @@ where
             .original_result()
     }
 
-    pub fn set_wegld_ticker<
-        Arg0: ProxyArg<ManagedBuffer<Env::Api>>,
-    >(
-        self,
-        wegld_ticker: Arg0,
-    ) -> TxTypedCall<Env, From, To, NotPayable, Gas, ()> {
-        self.wrapped_tx
-            .payment(NotPayable)
-            .raw_call("setWegldTicker")
-            .argument(&wegld_ticker)
-            .original_result()
-    }
-
     pub fn deposit<
         Arg0: ProxyArg<ManagedAddress<Env::Api>>,
         Arg1: ProxyArg<OptionalValue<MultiValue3<u64, ManagedBuffer<Env::Api>, ManagedVec<Env::Api, ManagedBuffer<Env::Api>>>>>,
diff --git a/enshrine-esdt-safe/wasm-enshrine-esdt-safe-full/src/lib.rs b/enshrine-esdt-safe/wasm-enshrine-esdt-safe-full/src/lib.rs
index ab0809b6..08014062 100644
--- a/enshrine-esdt-safe/wasm-enshrine-esdt-safe-full/src/lib.rs
+++ b/enshrine-esdt-safe/wasm-enshrine-esdt-safe-full/src/lib.rs
@@ -6,10 +6,10 @@
 
 // Init:                                 1
 // Upgrade:                              1
-// Endpoints:                           29
+// Endpoints:                           28
 // Async Callback:                       1
 // Promise callbacks:                    1
-// Total number of exported functions:  33
+// Total number of exported functions:  32
 
 #![no_std]
 
@@ -23,7 +23,6 @@ multiversx_sc_wasm_adapter::endpoints! {
         upgrade => upgrade
         setFeeMarketAddress => set_fee_market_address
         setHeaderVerifierAddress => set_header_verifier_address
-        setWegldTicker => set_wegld_ticker
         deposit => deposit
         setMinValidSigners => set_min_valid_signers
         addSigners => add_signers
diff --git a/enshrine-esdt-safe/wasm/src/lib.rs b/enshrine-esdt-safe/wasm/src/lib.rs
index ab0809b6..08014062 100644
--- a/enshrine-esdt-safe/wasm/src/lib.rs
+++ b/enshrine-esdt-safe/wasm/src/lib.rs
@@ -6,10 +6,10 @@
 
 // Init:                                 1
 // Upgrade:                              1
-// Endpoints:                           29
+// Endpoints:                           28
 // Async Callback:                       1
 // Promise callbacks:                    1
-// Total number of exported functions:  33
+// Total number of exported functions:  32
 
 #![no_std]
 
@@ -23,7 +23,6 @@ multiversx_sc_wasm_adapter::endpoints! {
         upgrade => upgrade
         setFeeMarketAddress => set_fee_market_address
         setHeaderVerifierAddress => set_header_verifier_address
-        setWegldTicker => set_wegld_ticker
         deposit => deposit
         setMinValidSigners => set_min_valid_signers
         addSigners => add_signers

From 33a7aabf9e5bb4fdeea8fc8675d40aa1ea17cbec Mon Sep 17 00:00:00 2001
From: Andrei Baltariu <andreibaltariu1304@gmail.com>
Date: Tue, 2 Jul 2024 15:59:55 +0300
Subject: [PATCH 33/76] Renamed init arg

---
 enshrine-esdt-safe/src/lib.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/enshrine-esdt-safe/src/lib.rs b/enshrine-esdt-safe/src/lib.rs
index 8713497e..90f581e2 100644
--- a/enshrine-esdt-safe/src/lib.rs
+++ b/enshrine-esdt-safe/src/lib.rs
@@ -24,12 +24,12 @@ pub trait EnshrineEsdtSafe:
     + common::storage::CommonStorage
 {
     #[init]
-    fn init(&self, is_sovereign_chain: bool, wegld_ticker: OptionalValue<ManagedBuffer>) {
+    fn init(&self, is_sovereign_chain: bool, wegld_identifier: OptionalValue<ManagedBuffer>) {
         self.is_sovereign_chain().set(is_sovereign_chain);
         self.set_paused(true);
 
         if !is_sovereign_chain {
-            match wegld_ticker {
+            match wegld_identifier {
                 OptionalValue::Some(ticker) => {
                     let identifier = TokenIdentifier::from(ticker);
                     if identifier.is_valid_esdt_identifier() {

From 1f5bff4a1e4c8d3922606cc93aca7a12c975901d Mon Sep 17 00:00:00 2001
From: Andrei Baltariu <andreibaltariu1304@gmail.com>
Date: Tue, 2 Jul 2024 16:01:46 +0300
Subject: [PATCH 34/76] Regenerated proxy

---
 enshrine-esdt-safe/src/enshrine_esdt_safe_proxy.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/enshrine-esdt-safe/src/enshrine_esdt_safe_proxy.rs b/enshrine-esdt-safe/src/enshrine_esdt_safe_proxy.rs
index ee0eca77..6a00ad9d 100644
--- a/enshrine-esdt-safe/src/enshrine_esdt_safe_proxy.rs
+++ b/enshrine-esdt-safe/src/enshrine_esdt_safe_proxy.rs
@@ -49,13 +49,13 @@ where
     >(
         self,
         is_sovereign_chain: Arg0,
-        wegld_ticker: Arg1,
+        wegld_identifier: Arg1,
     ) -> TxTypedDeploy<Env, From, NotPayable, Gas, ()> {
         self.wrapped_tx
             .payment(NotPayable)
             .raw_deploy()
             .argument(&is_sovereign_chain)
-            .argument(&wegld_ticker)
+            .argument(&wegld_identifier)
             .original_result()
     }
 }

From 098b0676e544436f822922f1ee93b630b80a4614 Mon Sep 17 00:00:00 2001
From: Andrei Baltariu <andreibaltariu1304@gmail.com>
Date: Wed, 3 Jul 2024 12:04:48 +0300
Subject: [PATCH 35/76] Added burn for sovereign tokens

---
 .../src/from_sovereign/transfer_tokens.rs     | 23 +++++++++++--------
 1 file changed, 14 insertions(+), 9 deletions(-)

diff --git a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
index 30a7b1b9..3e2d8d49 100644
--- a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
+++ b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
@@ -127,7 +127,7 @@ pub trait TransferTokensModule:
         wegld_amount -= DEFAULT_ISSUE_COST * unregistered_tokens_count;
 
         if first_payment.token_data.amount >= wegld_amount {
-            self.refund_wegld(sender, wegld_amount.clone());
+            self.refund_wegld(sender, wegld_amount);
             return tokens;
         }
 
@@ -290,6 +290,7 @@ pub trait TransferTokensModule:
                 );
             }
             ManagedAsyncCallResult::Err(_) => {
+                self.burn_sovereign_tokens(&operation_tuple.operation);
                 self.emit_transfer_failed_events(hash_of_hashes, operation_tuple);
             }
         }
@@ -303,6 +304,18 @@ pub trait TransferTokensModule:
             .sync_call();
     }
 
+    fn burn_sovereign_tokens(&self, operation: &Operation<Self::Api>) {
+        for token in operation.tokens.iter() {
+            if self.has_sov_token_prefix(&token.token_identifier) {
+                self.send().esdt_local_burn(
+                    &token.token_identifier,
+                    token.token_nonce,
+                    &token.token_data.amount,
+                );
+            }
+        }
+    }
+
     fn emit_transfer_failed_events(
         &self,
         hash_of_hashes: &ManagedBuffer,
@@ -313,14 +326,6 @@ pub trait TransferTokensModule:
             operation_tuple.op_hash.clone(),
         );
 
-        for operation_token in &operation_tuple.operation.tokens {
-            self.send().esdt_local_burn(
-                &operation_token.token_identifier,
-                operation_token.token_nonce,
-                &operation_token.token_data.amount,
-            );
-        }
-
         // deposit back mainchain tokens into user account
         let sc_address = self.blockchain().get_sc_address();
         let tx_nonce = self.get_and_save_next_tx_id();

From 83139b963384a5c89bc725294d81e3fdf2bf8849 Mon Sep 17 00:00:00 2001
From: Andrei Baltariu <andreibaltariu1304@gmail.com>
Date: Wed, 3 Jul 2024 13:57:18 +0300
Subject: [PATCH 36/76] Modified wegld fee function

---
 .../src/from_sovereign/transfer_tokens.rs     | 23 +++++++++++--------
 1 file changed, 14 insertions(+), 9 deletions(-)

diff --git a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
index 3e2d8d49..76611fd8 100644
--- a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
+++ b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
@@ -112,26 +112,31 @@ pub trait TransferTokensModule:
             return tokens;
         }
 
-        let mut wegld_amount = first_payment.token_data.amount.clone();
-        let mut unregistered_tokens_count = 0;
+        let mut unregistered_tokens: ManagedVec<TokenIdentifier> = ManagedVec::new();
 
         for token in tokens.iter().skip(1) {
             if !self.was_token_registered(&token.token_identifier)
                 && self.has_sov_token_prefix(&token.token_identifier)
             {
-                unregistered_tokens_count += 1;
-                self.register_token(token.token_identifier);
+                unregistered_tokens.push(token.token_identifier);
             }
         }
 
-        wegld_amount -= DEFAULT_ISSUE_COST * unregistered_tokens_count;
-
-        if first_payment.token_data.amount >= wegld_amount {
-            self.refund_wegld(sender, wegld_amount);
+        if unregistered_tokens.is_empty() {
             return tokens;
         }
 
-        tokens
+        let wegld_fee_amount = BigUint::from(DEFAULT_ISSUE_COST * unregistered_tokens.len() as u64);
+
+        if first_payment.token_data.amount >= wegld_fee_amount {
+            let mut registered_tokens = tokens.clone();
+            registered_tokens.remove(0);
+            self.refund_wegld(sender, wegld_fee_amount);
+
+            return registered_tokens;
+        }
+
+        sc_panic!("Not enough WEGLD to register all tokens");
     }
 
     fn refund_wegld(&self, sender: &ManagedAddress<Self::Api>, wegld_amount: BigUint<Self::Api>) {

From e1c516b2c9f3a4b2001b471f12087517be1361b4 Mon Sep 17 00:00:00 2001
From: Andrei Baltariu <andreibaltariu1304@gmail.com>
Date: Wed, 3 Jul 2024 14:00:12 +0300
Subject: [PATCH 37/76] Added bool return value to fee function

---
 .../src/from_sovereign/transfer_tokens.rs        | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
index 76611fd8..fe836a60 100644
--- a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
+++ b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
@@ -39,12 +39,12 @@ pub trait TransferTokensModule:
             sc_panic!("Operation is not registered");
         }
 
-        let remaining_tokens = self.verify_operation_tokens_for_issue_fee(
+        let (is_wegld_fee_paid, remaining_tokens) = self.verify_operation_tokens_for_issue_fee(
             &operation.data.op_sender,
             operation.tokens.clone(),
         );
 
-        if remaining_tokens.len() > 0 {
+        if is_wegld_fee_paid {
             let minted_operation_tokens = self.mint_tokens(&remaining_tokens);
             let operation_tuple = OperationTuple {
                 op_hash: operation_hash.clone(),
@@ -92,7 +92,7 @@ pub trait TransferTokensModule:
         &self,
         sender: &ManagedAddress<Self::Api>,
         tokens: ManagedVec<OperationEsdtPayment<Self::Api>>,
-    ) -> ManagedVec<OperationEsdtPayment<Self::Api>> {
+    ) -> (bool, ManagedVec<OperationEsdtPayment<Self::Api>>) {
         let first_payment = tokens.get(0);
         let is_first_payment_wegld = self.is_wegld(&first_payment.token_identifier);
 
@@ -101,15 +101,15 @@ pub trait TransferTokensModule:
                 if !self.was_token_registered(&token.token_identifier)
                     && self.has_sov_token_prefix(&token.token_identifier)
                 {
-                    return ManagedVec::new();
+                    return (false, ManagedVec::new());
                 }
             }
 
-            return tokens;
+            return (true, tokens);
         }
 
         if is_first_payment_wegld && tokens.len() == 1 {
-            return tokens;
+            return (true, tokens);
         }
 
         let mut unregistered_tokens: ManagedVec<TokenIdentifier> = ManagedVec::new();
@@ -123,7 +123,7 @@ pub trait TransferTokensModule:
         }
 
         if unregistered_tokens.is_empty() {
-            return tokens;
+            return (true, tokens);
         }
 
         let wegld_fee_amount = BigUint::from(DEFAULT_ISSUE_COST * unregistered_tokens.len() as u64);
@@ -133,7 +133,7 @@ pub trait TransferTokensModule:
             registered_tokens.remove(0);
             self.refund_wegld(sender, wegld_fee_amount);
 
-            return registered_tokens;
+            return (true, registered_tokens);
         }
 
         sc_panic!("Not enough WEGLD to register all tokens");

From a1b2738785ce922e4be88d6729e6287f28d3c9c8 Mon Sep 17 00:00:00 2001
From: Andrei Baltariu <andreibaltariu1304@gmail.com>
Date: Wed, 3 Jul 2024 14:29:24 +0300
Subject: [PATCH 38/76] Added register token call

---
 enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
index fe836a60..0139d790 100644
--- a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
+++ b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
@@ -93,6 +93,8 @@ pub trait TransferTokensModule:
         sender: &ManagedAddress<Self::Api>,
         tokens: ManagedVec<OperationEsdtPayment<Self::Api>>,
     ) -> (bool, ManagedVec<OperationEsdtPayment<Self::Api>>) {
+        require!(!tokens.is_empty(), "Tokens array should not be empty");
+
         let first_payment = tokens.get(0);
         let is_first_payment_wegld = self.is_wegld(&first_payment.token_identifier);
 
@@ -129,6 +131,10 @@ pub trait TransferTokensModule:
         let wegld_fee_amount = BigUint::from(DEFAULT_ISSUE_COST * unregistered_tokens.len() as u64);
 
         if first_payment.token_data.amount >= wegld_fee_amount {
+            for token_identifier in unregistered_tokens.iter() {
+                self.register_token(token_identifier.clone_value());
+            }
+
             let mut registered_tokens = tokens.clone();
             registered_tokens.remove(0);
             self.refund_wegld(sender, wegld_fee_amount);

From 1bff454ab074c4771ca7021e7531e7c77129709f Mon Sep 17 00:00:00 2001
From: Andrei Baltariu <andreibaltariu1304@gmail.com>
Date: Wed, 3 Jul 2024 14:30:37 +0300
Subject: [PATCH 39/76] Removed clone call

---
 enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
index 0139d790..c00cec39 100644
--- a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
+++ b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
@@ -135,7 +135,7 @@ pub trait TransferTokensModule:
                 self.register_token(token_identifier.clone_value());
             }
 
-            let mut registered_tokens = tokens.clone();
+            let mut registered_tokens = tokens;
             registered_tokens.remove(0);
             self.refund_wegld(sender, wegld_fee_amount);
 

From 4cfc7c69a1593a86075d9c9428e63bc93fa56cd4 Mon Sep 17 00:00:00 2001
From: Andrei Baltariu <andreibaltariu1304@gmail.com>
Date: Wed, 3 Jul 2024 15:47:28 +0300
Subject: [PATCH 40/76] Modified wegld fee calculation

---
 enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
index c00cec39..82b955e8 100644
--- a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
+++ b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
@@ -137,7 +137,7 @@ pub trait TransferTokensModule:
 
             let mut registered_tokens = tokens;
             registered_tokens.remove(0);
-            self.refund_wegld(sender, wegld_fee_amount);
+            self.refund_wegld(sender, first_payment.token_data.amount - wegld_fee_amount);
 
             return (true, registered_tokens);
         }

From 87cafe7dca94cb4ddfb8cc8ce2d7ba05e28fc024 Mon Sep 17 00:00:00 2001
From: Andrei Baltariu <andreibaltariu1304@gmail.com>
Date: Wed, 3 Jul 2024 16:00:50 +0300
Subject: [PATCH 41/76] Reverted condition in execute_operations

---
 .../src/from_sovereign/transfer_tokens.rs     | 38 +++++++++----------
 1 file changed, 19 insertions(+), 19 deletions(-)

diff --git a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
index 82b955e8..59f05e2a 100644
--- a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
+++ b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
@@ -44,26 +44,28 @@ pub trait TransferTokensModule:
             operation.tokens.clone(),
         );
 
-        if is_wegld_fee_paid {
-            let minted_operation_tokens = self.mint_tokens(&remaining_tokens);
-            let operation_tuple = OperationTuple {
-                op_hash: operation_hash.clone(),
-                operation: operation.clone(),
-            };
-
-            self.distribute_payments(
-                hash_of_hashes.clone(),
-                operation_tuple,
-                minted_operation_tokens,
+        if !is_wegld_fee_paid {
+            self.emit_transfer_failed_events(
+                &hash_of_hashes,
+                &OperationTuple {
+                    op_hash: operation_hash,
+                    operation,
+                },
             );
+
+            sc_panic!("Not enough WEGLD to register all tokens");
         }
 
-        self.emit_transfer_failed_events(
-            &hash_of_hashes,
-            &OperationTuple {
-                op_hash: operation_hash,
-                operation,
-            },
+        let minted_operation_tokens = self.mint_tokens(&remaining_tokens);
+        let operation_tuple = OperationTuple {
+            op_hash: operation_hash.clone(),
+            operation: operation.clone(),
+        };
+
+        self.distribute_payments(
+            hash_of_hashes.clone(),
+            operation_tuple,
+            minted_operation_tokens,
         );
     }
 
@@ -141,8 +143,6 @@ pub trait TransferTokensModule:
 
             return (true, registered_tokens);
         }
-
-        sc_panic!("Not enough WEGLD to register all tokens");
     }
 
     fn refund_wegld(&self, sender: &ManagedAddress<Self::Api>, wegld_amount: BigUint<Self::Api>) {

From 32fb9ac5cb8964cb1dfa664ec524a33ae212aa2a Mon Sep 17 00:00:00 2001
From: Andrei Baltariu <andreibaltariu1304@gmail.com>
Date: Wed, 3 Jul 2024 16:05:09 +0300
Subject: [PATCH 42/76] Added else scenario for wegld fee

---
 enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
index 59f05e2a..f6ed389c 100644
--- a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
+++ b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
@@ -143,6 +143,8 @@ pub trait TransferTokensModule:
 
             return (true, registered_tokens);
         }
+
+        (false, tokens)
     }
 
     fn refund_wegld(&self, sender: &ManagedAddress<Self::Api>, wegld_amount: BigUint<Self::Api>) {

From 07d92fcda28e092778aa788be6422c37fcd5c8fd Mon Sep 17 00:00:00 2001
From: Andrei Baltariu <andreibaltariu1304@gmail.com>
Date: Wed, 3 Jul 2024 16:27:36 +0300
Subject: [PATCH 43/76] Added require check + changed return value

---
 enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
index f6ed389c..3db3fe91 100644
--- a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
+++ b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
@@ -144,10 +144,12 @@ pub trait TransferTokensModule:
             return (true, registered_tokens);
         }
 
-        (false, tokens)
+        (false, ManagedVec::new())
     }
 
     fn refund_wegld(&self, sender: &ManagedAddress<Self::Api>, wegld_amount: BigUint<Self::Api>) {
+        require!(wegld_amount > 0, "No WEGLD fee sent");
+
         let wegld_identifier = self.wegld_identifier().get();
         let payment = EsdtTokenPayment::new(wegld_identifier, 0, wegld_amount);
 

From e426908877a153abc27876e8710acb18befe7c9b Mon Sep 17 00:00:00 2001
From: Andrei Baltariu <andreibaltariu1304@gmail.com>
Date: Thu, 4 Jul 2024 10:44:14 +0300
Subject: [PATCH 44/76] Modified wegld fee and inline function logic

---
 .../src/from_sovereign/transfer_tokens.rs     | 32 ++++++++-----------
 1 file changed, 14 insertions(+), 18 deletions(-)

diff --git a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
index 3db3fe91..fc3b6839 100644
--- a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
+++ b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
@@ -102,15 +102,13 @@ pub trait TransferTokensModule:
 
         if !is_first_payment_wegld {
             for token in tokens.iter() {
-                if !self.was_token_registered(&token.token_identifier)
-                    && self.has_sov_token_prefix(&token.token_identifier)
-                {
+                if !self.was_token_registered(&token.token_identifier) {
                     return (false, ManagedVec::new());
                 }
             }
 
             return (true, tokens);
-        }
+        };
 
         if is_first_payment_wegld && tokens.len() == 1 {
             return (true, tokens);
@@ -119,9 +117,7 @@ pub trait TransferTokensModule:
         let mut unregistered_tokens: ManagedVec<TokenIdentifier> = ManagedVec::new();
 
         for token in tokens.iter().skip(1) {
-            if !self.was_token_registered(&token.token_identifier)
-                && self.has_sov_token_prefix(&token.token_identifier)
-            {
+            if !self.was_token_registered(&token.token_identifier) {
                 unregistered_tokens.push(token.token_identifier);
             }
         }
@@ -131,20 +127,20 @@ pub trait TransferTokensModule:
         }
 
         let wegld_fee_amount = BigUint::from(DEFAULT_ISSUE_COST * unregistered_tokens.len() as u64);
+        let mut registered_tokens = tokens;
+        registered_tokens.remove(0);
 
-        if first_payment.token_data.amount >= wegld_fee_amount {
-            for token_identifier in unregistered_tokens.iter() {
-                self.register_token(token_identifier.clone_value());
-            }
-
-            let mut registered_tokens = tokens;
-            registered_tokens.remove(0);
-            self.refund_wegld(sender, first_payment.token_data.amount - wegld_fee_amount);
+        if first_payment.token_data.amount < wegld_fee_amount {
+            return (false, ManagedVec::new());
+        }
 
-            return (true, registered_tokens);
+        for token_identifier in unregistered_tokens.iter() {
+            self.register_token(token_identifier.clone_value());
         }
 
-        (false, ManagedVec::new())
+        self.refund_wegld(sender, first_payment.token_data.amount - wegld_fee_amount);
+
+        return (true, registered_tokens);
     }
 
     fn refund_wegld(&self, sender: &ManagedAddress<Self::Api>, wegld_amount: BigUint<Self::Api>) {
@@ -385,7 +381,7 @@ pub trait TransferTokensModule:
 
     #[inline]
     fn was_token_registered(&self, token_id: &TokenIdentifier<Self::Api>) -> bool {
-        self.paid_issued_tokens().contains(token_id)
+        self.has_sov_token_prefix(token_id) && self.paid_issued_tokens().contains(token_id)
     }
 
     #[inline]

From 74c97f73f31704cb601e09dd538491a09c729486 Mon Sep 17 00:00:00 2001
From: Andrei Baltariu <andreibaltariu1304@gmail.com>
Date: Thu, 4 Jul 2024 10:45:57 +0300
Subject: [PATCH 45/76] Switched returned types

---
 .../src/from_sovereign/transfer_tokens.rs        | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
index fc3b6839..4ac3cb64 100644
--- a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
+++ b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
@@ -39,7 +39,7 @@ pub trait TransferTokensModule:
             sc_panic!("Operation is not registered");
         }
 
-        let (is_wegld_fee_paid, remaining_tokens) = self.verify_operation_tokens_for_issue_fee(
+        let (remaining_tokens, is_wegld_fee_paid) = self.verify_operation_tokens_for_issue_fee(
             &operation.data.op_sender,
             operation.tokens.clone(),
         );
@@ -94,7 +94,7 @@ pub trait TransferTokensModule:
         &self,
         sender: &ManagedAddress<Self::Api>,
         tokens: ManagedVec<OperationEsdtPayment<Self::Api>>,
-    ) -> (bool, ManagedVec<OperationEsdtPayment<Self::Api>>) {
+    ) -> (ManagedVec<OperationEsdtPayment<Self::Api>>, bool) {
         require!(!tokens.is_empty(), "Tokens array should not be empty");
 
         let first_payment = tokens.get(0);
@@ -103,15 +103,15 @@ pub trait TransferTokensModule:
         if !is_first_payment_wegld {
             for token in tokens.iter() {
                 if !self.was_token_registered(&token.token_identifier) {
-                    return (false, ManagedVec::new());
+                    return (ManagedVec::new(), false);
                 }
             }
 
-            return (true, tokens);
+            return (tokens, false);
         };
 
         if is_first_payment_wegld && tokens.len() == 1 {
-            return (true, tokens);
+            return (tokens, false);
         }
 
         let mut unregistered_tokens: ManagedVec<TokenIdentifier> = ManagedVec::new();
@@ -123,7 +123,7 @@ pub trait TransferTokensModule:
         }
 
         if unregistered_tokens.is_empty() {
-            return (true, tokens);
+            return (tokens, true);
         }
 
         let wegld_fee_amount = BigUint::from(DEFAULT_ISSUE_COST * unregistered_tokens.len() as u64);
@@ -131,7 +131,7 @@ pub trait TransferTokensModule:
         registered_tokens.remove(0);
 
         if first_payment.token_data.amount < wegld_fee_amount {
-            return (false, ManagedVec::new());
+            return (ManagedVec::new(), false);
         }
 
         for token_identifier in unregistered_tokens.iter() {
@@ -140,7 +140,7 @@ pub trait TransferTokensModule:
 
         self.refund_wegld(sender, first_payment.token_data.amount - wegld_fee_amount);
 
-        return (true, registered_tokens);
+        return (registered_tokens, false);
     }
 
     fn refund_wegld(&self, sender: &ManagedAddress<Self::Api>, wegld_amount: BigUint<Self::Api>) {

From 015c2d4bdfc463196a8821411f02ed966f30c693 Mon Sep 17 00:00:00 2001
From: Andrei Baltariu <andreibaltariu1304@gmail.com>
Date: Thu, 4 Jul 2024 12:31:35 +0300
Subject: [PATCH 46/76] Added default function for OperationEsdtPayment

---
 common/transaction/src/lib.rs | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/common/transaction/src/lib.rs b/common/transaction/src/lib.rs
index 550155a4..2e9a2e03 100644
--- a/common/transaction/src/lib.rs
+++ b/common/transaction/src/lib.rs
@@ -90,6 +90,16 @@ impl<M: ManagedTypeApi> From<OperationEsdtPayment<M>> for EsdtTokenPayment<M> {
     }
 }
 
+impl<M: ManagedTypeApi> Default for OperationEsdtPayment<M> {
+    fn default() -> Self {
+        OperationEsdtPayment {
+            token_identifier: TokenIdentifier::from(ManagedBuffer::new()),
+            token_nonce: 0,
+            token_data: StolenFromFrameworkEsdtTokenData::default(),
+        }
+    }
+}
+
 // Temporary until Clone is implemented for EsdtTokenData
 #[derive(
     TopDecode, TopEncode, NestedDecode, NestedEncode, TypeAbi, Debug, ManagedVecItem, Clone,

From 5352b44c79cf10481ff76e9d72a796b20a2db2df Mon Sep 17 00:00:00 2001
From: Andrei Baltariu <andreibaltariu1304@gmail.com>
Date: Thu, 4 Jul 2024 12:40:15 +0300
Subject: [PATCH 47/76] Added get_wegld_payment function

---
 .../src/from_sovereign/transfer_tokens.rs     | 22 ++++++++++++++-----
 1 file changed, 17 insertions(+), 5 deletions(-)

diff --git a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
index 4ac3cb64..a94a30ef 100644
--- a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
+++ b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
@@ -90,15 +90,27 @@ pub trait TransferTokensModule:
         }
     }
 
+    fn get_wegld_payment(
+        &self,
+        tokens: &ManagedVec<OperationEsdtPayment<Self::Api>>,
+    ) -> OperationEsdtPayment<Self::Api> {
+        for token in tokens.iter() {
+            if self.is_wegld(&token.token_identifier) {
+                return token;
+            }
+        }
+
+        OperationEsdtPayment::default()
+    }
+
     fn verify_operation_tokens_for_issue_fee(
         &self,
         sender: &ManagedAddress<Self::Api>,
         tokens: ManagedVec<OperationEsdtPayment<Self::Api>>,
     ) -> (ManagedVec<OperationEsdtPayment<Self::Api>>, bool) {
         require!(!tokens.is_empty(), "Tokens array should not be empty");
-
-        let first_payment = tokens.get(0);
-        let is_first_payment_wegld = self.is_wegld(&first_payment.token_identifier);
+        let wegld_payment = self.get_wegld_payment(&tokens);
+        let is_first_payment_wegld = self.is_wegld(&wegld_payment.token_identifier);
 
         if !is_first_payment_wegld {
             for token in tokens.iter() {
@@ -130,7 +142,7 @@ pub trait TransferTokensModule:
         let mut registered_tokens = tokens;
         registered_tokens.remove(0);
 
-        if first_payment.token_data.amount < wegld_fee_amount {
+        if wegld_payment.token_data.amount < wegld_fee_amount {
             return (ManagedVec::new(), false);
         }
 
@@ -138,7 +150,7 @@ pub trait TransferTokensModule:
             self.register_token(token_identifier.clone_value());
         }
 
-        self.refund_wegld(sender, first_payment.token_data.amount - wegld_fee_amount);
+        self.refund_wegld(sender, wegld_payment.token_data.amount - wegld_fee_amount);
 
         return (registered_tokens, false);
     }

From 8ed2d0af74dbed7feb8e2c4c94716bf6db3e1968 Mon Sep 17 00:00:00 2001
From: Andrei Baltariu <andreibaltariu1304@gmail.com>
Date: Thu, 4 Jul 2024 13:43:53 +0300
Subject: [PATCH 48/76] Modified get_wegld_payment to return index

---
 .../src/from_sovereign/transfer_tokens.rs     | 23 +++++++++++--------
 1 file changed, 13 insertions(+), 10 deletions(-)

diff --git a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
index a94a30ef..92cb830f 100644
--- a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
+++ b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
@@ -1,3 +1,5 @@
+use core::iter::empty;
+
 use crate::{common, to_sovereign};
 use builtin_func_names::ESDT_NFT_CREATE_FUNC_NAME;
 use header_verifier::header_verifier_proxy;
@@ -93,14 +95,14 @@ pub trait TransferTokensModule:
     fn get_wegld_payment(
         &self,
         tokens: &ManagedVec<OperationEsdtPayment<Self::Api>>,
-    ) -> OperationEsdtPayment<Self::Api> {
-        for token in tokens.iter() {
+    ) -> (OperationEsdtPayment<Self::Api>, usize) {
+        for (i, token) in tokens.iter().enumerate() {
             if self.is_wegld(&token.token_identifier) {
-                return token;
+                return (token, i);
             }
         }
 
-        OperationEsdtPayment::default()
+        (OperationEsdtPayment::default(), 0)
     }
 
     fn verify_operation_tokens_for_issue_fee(
@@ -109,10 +111,11 @@ pub trait TransferTokensModule:
         tokens: ManagedVec<OperationEsdtPayment<Self::Api>>,
     ) -> (ManagedVec<OperationEsdtPayment<Self::Api>>, bool) {
         require!(!tokens.is_empty(), "Tokens array should not be empty");
-        let wegld_payment = self.get_wegld_payment(&tokens);
-        let is_first_payment_wegld = self.is_wegld(&wegld_payment.token_identifier);
+        let (wegld_payment, wegld_position) = self.get_wegld_payment(&tokens);
+        let is_empty_identifier =
+            wegld_payment.token_identifier == TokenIdentifier::from(ManagedBuffer::new());
 
-        if !is_first_payment_wegld {
+        if is_empty_identifier {
             for token in tokens.iter() {
                 if !self.was_token_registered(&token.token_identifier) {
                     return (ManagedVec::new(), false);
@@ -122,13 +125,13 @@ pub trait TransferTokensModule:
             return (tokens, false);
         };
 
-        if is_first_payment_wegld && tokens.len() == 1 {
+        if !is_empty_identifier && tokens.len() == 1 {
             return (tokens, false);
         }
 
         let mut unregistered_tokens: ManagedVec<TokenIdentifier> = ManagedVec::new();
 
-        for token in tokens.iter().skip(1) {
+        for token in tokens.iter() {
             if !self.was_token_registered(&token.token_identifier) {
                 unregistered_tokens.push(token.token_identifier);
             }
@@ -140,7 +143,7 @@ pub trait TransferTokensModule:
 
         let wegld_fee_amount = BigUint::from(DEFAULT_ISSUE_COST * unregistered_tokens.len() as u64);
         let mut registered_tokens = tokens;
-        registered_tokens.remove(0);
+        registered_tokens.remove(wegld_position);
 
         if wegld_payment.token_data.amount < wegld_fee_amount {
             return (ManagedVec::new(), false);

From a26458a0e667ab522b262d3191188f0d9702b526 Mon Sep 17 00:00:00 2001
From: Andrei Baltariu <andreibaltariu1304@gmail.com>
Date: Thu, 4 Jul 2024 13:52:21 +0300
Subject: [PATCH 49/76] Added new endpoint for WEGLD deposit

---
 .../src/from_sovereign/transfer_tokens.rs           | 13 +++++++++++--
 1 file changed, 11 insertions(+), 2 deletions(-)

diff --git a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
index 92cb830f..68349ea9 100644
--- a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
+++ b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
@@ -1,5 +1,3 @@
-use core::iter::empty;
-
 use crate::{common, to_sovereign};
 use builtin_func_names::ESDT_NFT_CREATE_FUNC_NAME;
 use header_verifier::header_verifier_proxy;
@@ -92,6 +90,17 @@ pub trait TransferTokensModule:
         }
     }
 
+    #[endpoint(depositForNewRegistrations)]
+    #[payable("*")]
+    fn deposit_for_new_registrations(&self) {
+        let call_value = self.call_value().single_esdt();
+
+        require!(
+            call_value.amount >= DEFAULT_ISSUE_COST,
+            "The minimum amount of WEGLD wasn't met"
+        );
+    }
+
     fn get_wegld_payment(
         &self,
         tokens: &ManagedVec<OperationEsdtPayment<Self::Api>>,

From ae5d9757879a863c6818073fd59bf8a0e9235341 Mon Sep 17 00:00:00 2001
From: Andrei Baltariu <andreibaltariu1304@gmail.com>
Date: Thu, 4 Jul 2024 14:08:41 +0300
Subject: [PATCH 50/76] Modified prefix function and added sov prefix to init

---
 common/utils/src/lib.rs                       |  2 +-
 enshrine-esdt-safe/src/common/storage.rs      |  3 +++
 .../src/from_sovereign/transfer_tokens.rs     |  6 ++---
 enshrine-esdt-safe/src/lib.rs                 | 22 +++++++++++++++----
 .../src/to_sovereign/create_tx.rs             |  4 +---
 5 files changed, 26 insertions(+), 11 deletions(-)

diff --git a/common/utils/src/lib.rs b/common/utils/src/lib.rs
index a23551a7..dcbd2c36 100644
--- a/common/utils/src/lib.rs
+++ b/common/utils/src/lib.rs
@@ -66,7 +66,7 @@ pub trait UtilsModule: bls_signature::BlsSignatureModule {
         list
     }
 
-    fn has_sov_token_prefix(&self, token_id: &TokenIdentifier) -> bool {
+    fn has_prefix(&self, token_id: &TokenIdentifier) -> bool {
         let dash = b'-';
         let buffer = token_id.as_managed_buffer();
         let mut array_buffer = [0u8; 32];
diff --git a/enshrine-esdt-safe/src/common/storage.rs b/enshrine-esdt-safe/src/common/storage.rs
index 3857e6a1..331e4de6 100644
--- a/enshrine-esdt-safe/src/common/storage.rs
+++ b/enshrine-esdt-safe/src/common/storage.rs
@@ -7,4 +7,7 @@ pub trait CommonStorage {
 
     #[storage_mapper("wegldIdentifier")]
     fn wegld_identifier(&self) -> SingleValueMapper<TokenIdentifier>;
+
+    #[storage_mapper("sovereignTokenPrefix")]
+    fn sovereign_token_prefix(&self) -> SingleValueMapper<ManagedBuffer>;
 }
diff --git a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
index 68349ea9..55cd7a1c 100644
--- a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
+++ b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
@@ -183,7 +183,7 @@ pub trait TransferTokensModule:
         let mut output_payments = ManagedVec::new();
 
         for operation_token in operation_tokens.iter() {
-            if !self.has_sov_token_prefix(&operation_token.token_identifier) {
+            if !self.has_prefix(&operation_token.token_identifier) {
                 output_payments.push(operation_token.clone());
                 continue;
             }
@@ -341,7 +341,7 @@ pub trait TransferTokensModule:
 
     fn burn_sovereign_tokens(&self, operation: &Operation<Self::Api>) {
         for token in operation.tokens.iter() {
-            if self.has_sov_token_prefix(&token.token_identifier) {
+            if self.has_prefix(&token.token_identifier) {
                 self.send().esdt_local_burn(
                     &token.token_identifier,
                     token.token_nonce,
@@ -405,7 +405,7 @@ pub trait TransferTokensModule:
 
     #[inline]
     fn was_token_registered(&self, token_id: &TokenIdentifier<Self::Api>) -> bool {
-        self.has_sov_token_prefix(token_id) && self.paid_issued_tokens().contains(token_id)
+        self.has_prefix(token_id) && self.paid_issued_tokens().contains(token_id)
     }
 
     #[inline]
diff --git a/enshrine-esdt-safe/src/lib.rs b/enshrine-esdt-safe/src/lib.rs
index 90f581e2..870a34ee 100644
--- a/enshrine-esdt-safe/src/lib.rs
+++ b/enshrine-esdt-safe/src/lib.rs
@@ -24,19 +24,33 @@ pub trait EnshrineEsdtSafe:
     + common::storage::CommonStorage
 {
     #[init]
-    fn init(&self, is_sovereign_chain: bool, wegld_identifier: OptionalValue<ManagedBuffer>) {
+    fn init(
+        &self,
+        is_sovereign_chain: bool,
+        wegld_identifier: OptionalValue<ManagedBuffer>,
+        sov_token_prefix: OptionalValue<ManagedBuffer>,
+    ) {
         self.is_sovereign_chain().set(is_sovereign_chain);
         self.set_paused(true);
 
         if !is_sovereign_chain {
-            match wegld_identifier {
-                OptionalValue::Some(ticker) => {
+            match (wegld_identifier, sov_token_prefix) {
+                (OptionalValue::Some(ticker), OptionalValue::Some(prefix)) => {
                     let identifier = TokenIdentifier::from(ticker);
                     if identifier.is_valid_esdt_identifier() {
                         self.wegld_identifier().set(identifier);
+                        self.sovereign_token_prefix().set(prefix);
                     }
                 }
-                OptionalValue::None => sc_panic!("WEGLD identifier must be set in Mainchain"),
+                (OptionalValue::Some(_), OptionalValue::None) => {
+                    sc_panic!("Sovereign Token Prefix must be set in Mainchain")
+                }
+                (OptionalValue::None, OptionalValue::Some(_)) => {
+                    sc_panic!("WEGLG identifier must be set in Mainchain")
+                }
+                _ => sc_panic!(
+                    "Both WEGLD identifier and Sovereign Token Prefix must be set in Mainchain"
+                ),
             }
         }
     }
diff --git a/enshrine-esdt-safe/src/to_sovereign/create_tx.rs b/enshrine-esdt-safe/src/to_sovereign/create_tx.rs
index aafd5cef..59d0f9ae 100644
--- a/enshrine-esdt-safe/src/to_sovereign/create_tx.rs
+++ b/enshrine-esdt-safe/src/to_sovereign/create_tx.rs
@@ -69,9 +69,7 @@ pub trait CreateTxModule:
 
             current_token_data.amount = payment.amount.clone();
 
-            if self.is_sovereign_chain().get()
-                || self.has_sov_token_prefix(&payment.token_identifier)
-            {
+            if self.is_sovereign_chain().get() || self.has_prefix(&payment.token_identifier) {
                 self.send().esdt_local_burn(
                     &payment.token_identifier,
                     payment.token_nonce,

From 86f397e73163ccc293d6ea5624fd35000c0e3ac9 Mon Sep 17 00:00:00 2001
From: Andrei Baltariu <andreibaltariu1304@gmail.com>
Date: Thu, 4 Jul 2024 14:15:27 +0300
Subject: [PATCH 51/76] Added inline prefix check function

---
 common/utils/src/lib.rs | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/common/utils/src/lib.rs b/common/utils/src/lib.rs
index dcbd2c36..371d2d75 100644
--- a/common/utils/src/lib.rs
+++ b/common/utils/src/lib.rs
@@ -80,4 +80,11 @@ pub trait UtilsModule: bls_signature::BlsSignatureModule {
 
         false
     }
+
+    #[inline]
+    fn has_sov_prefix(&self, token_id: &TokenIdentifier, sov_prefix: ManagedBuffer) -> bool {
+        require!(self.has_prefix(token_id), "Token does not have prefix");
+
+        *token_id == TokenIdentifier::from(sov_prefix)
+    }
 }

From b6a8743fd81e6e741d1cf83199f3966c53429035 Mon Sep 17 00:00:00 2001
From: Andrei Baltariu <andreibaltariu1304@gmail.com>
Date: Thu, 4 Jul 2024 14:20:03 +0300
Subject: [PATCH 52/76] Modified inline function and used new has_sov_prefix
 function

---
 .../src/from_sovereign/transfer_tokens.rs         | 15 ++++++++++++---
 1 file changed, 12 insertions(+), 3 deletions(-)

diff --git a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
index 55cd7a1c..78c99145 100644
--- a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
+++ b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
@@ -183,7 +183,10 @@ pub trait TransferTokensModule:
         let mut output_payments = ManagedVec::new();
 
         for operation_token in operation_tokens.iter() {
-            if !self.has_prefix(&operation_token.token_identifier) {
+            if !self.has_sov_prefix(
+                &operation_token.token_identifier,
+                self.get_sovereign_prefix(),
+            ) {
                 output_payments.push(operation_token.clone());
                 continue;
             }
@@ -341,7 +344,7 @@ pub trait TransferTokensModule:
 
     fn burn_sovereign_tokens(&self, operation: &Operation<Self::Api>) {
         for token in operation.tokens.iter() {
-            if self.has_prefix(&token.token_identifier) {
+            if self.has_sov_prefix(&token.token_identifier, self.get_sovereign_prefix()) {
                 self.send().esdt_local_burn(
                     &token.token_identifier,
                     token.token_nonce,
@@ -405,7 +408,13 @@ pub trait TransferTokensModule:
 
     #[inline]
     fn was_token_registered(&self, token_id: &TokenIdentifier<Self::Api>) -> bool {
-        self.has_prefix(token_id) && self.paid_issued_tokens().contains(token_id)
+        self.has_sov_prefix(token_id, self.get_sovereign_prefix())
+            && self.paid_issued_tokens().contains(token_id)
+    }
+
+    #[inline]
+    fn get_sovereign_prefix(&self) -> ManagedBuffer {
+        self.sovereign_token_prefix().get()
     }
 
     #[inline]

From 3dcf59ca6096c76f0cf8c96247d1a8757026e25f Mon Sep 17 00:00:00 2001
From: Andrei Baltariu <andreibaltariu1304@gmail.com>
Date: Thu, 4 Jul 2024 14:45:40 +0300
Subject: [PATCH 53/76] Switched from OptionalValue to Option

---
 enshrine-esdt-safe/src/lib.rs | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/enshrine-esdt-safe/src/lib.rs b/enshrine-esdt-safe/src/lib.rs
index 870a34ee..3411d77e 100644
--- a/enshrine-esdt-safe/src/lib.rs
+++ b/enshrine-esdt-safe/src/lib.rs
@@ -27,25 +27,25 @@ pub trait EnshrineEsdtSafe:
     fn init(
         &self,
         is_sovereign_chain: bool,
-        wegld_identifier: OptionalValue<ManagedBuffer>,
-        sov_token_prefix: OptionalValue<ManagedBuffer>,
+        wegld_identifier: Option<ManagedBuffer>,
+        sov_token_prefix: Option<ManagedBuffer>,
     ) {
         self.is_sovereign_chain().set(is_sovereign_chain);
         self.set_paused(true);
 
         if !is_sovereign_chain {
             match (wegld_identifier, sov_token_prefix) {
-                (OptionalValue::Some(ticker), OptionalValue::Some(prefix)) => {
+                (Some(ticker), Some(prefix)) => {
                     let identifier = TokenIdentifier::from(ticker);
                     if identifier.is_valid_esdt_identifier() {
                         self.wegld_identifier().set(identifier);
                         self.sovereign_token_prefix().set(prefix);
                     }
                 }
-                (OptionalValue::Some(_), OptionalValue::None) => {
+                (Some(_), None) => {
                     sc_panic!("Sovereign Token Prefix must be set in Mainchain")
                 }
-                (OptionalValue::None, OptionalValue::Some(_)) => {
+                (None, Some(_)) => {
                     sc_panic!("WEGLG identifier must be set in Mainchain")
                 }
                 _ => sc_panic!(

From 9eee6b97ac44785a40a95e74b58f76d837baea42 Mon Sep 17 00:00:00 2001
From: Andrei Baltariu <andreibaltariu1304@gmail.com>
Date: Thu, 4 Jul 2024 14:51:02 +0300
Subject: [PATCH 54/76] Modified get_wegld logic to return BigUint and isize
 index

---
 .../src/from_sovereign/transfer_tokens.rs     | 22 +++++++++----------
 1 file changed, 10 insertions(+), 12 deletions(-)

diff --git a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
index 78c99145..54797440 100644
--- a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
+++ b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
@@ -101,17 +101,17 @@ pub trait TransferTokensModule:
         );
     }
 
-    fn get_wegld_payment(
+    fn get_wegld_payment_info(
         &self,
         tokens: &ManagedVec<OperationEsdtPayment<Self::Api>>,
-    ) -> (OperationEsdtPayment<Self::Api>, usize) {
+    ) -> (BigUint, isize) {
         for (i, token) in tokens.iter().enumerate() {
             if self.is_wegld(&token.token_identifier) {
-                return (token, i);
+                return (token.token_data.amount, i as isize);
             }
         }
 
-        (OperationEsdtPayment::default(), 0)
+        (BigUint::from(0u32), -1)
     }
 
     fn verify_operation_tokens_for_issue_fee(
@@ -120,11 +120,9 @@ pub trait TransferTokensModule:
         tokens: ManagedVec<OperationEsdtPayment<Self::Api>>,
     ) -> (ManagedVec<OperationEsdtPayment<Self::Api>>, bool) {
         require!(!tokens.is_empty(), "Tokens array should not be empty");
-        let (wegld_payment, wegld_position) = self.get_wegld_payment(&tokens);
-        let is_empty_identifier =
-            wegld_payment.token_identifier == TokenIdentifier::from(ManagedBuffer::new());
+        let (wegld_amount, wegld_position) = self.get_wegld_payment_info(&tokens);
 
-        if is_empty_identifier {
+        if wegld_position == -1 {
             for token in tokens.iter() {
                 if !self.was_token_registered(&token.token_identifier) {
                     return (ManagedVec::new(), false);
@@ -134,7 +132,7 @@ pub trait TransferTokensModule:
             return (tokens, false);
         };
 
-        if !is_empty_identifier && tokens.len() == 1 {
+        if wegld_position >= 0 && tokens.len() == 1 {
             return (tokens, false);
         }
 
@@ -152,9 +150,9 @@ pub trait TransferTokensModule:
 
         let wegld_fee_amount = BigUint::from(DEFAULT_ISSUE_COST * unregistered_tokens.len() as u64);
         let mut registered_tokens = tokens;
-        registered_tokens.remove(wegld_position);
+        registered_tokens.remove(wegld_position as usize);
 
-        if wegld_payment.token_data.amount < wegld_fee_amount {
+        if wegld_amount < wegld_fee_amount {
             return (ManagedVec::new(), false);
         }
 
@@ -162,7 +160,7 @@ pub trait TransferTokensModule:
             self.register_token(token_identifier.clone_value());
         }
 
-        self.refund_wegld(sender, wegld_payment.token_data.amount - wegld_fee_amount);
+        self.refund_wegld(sender, wegld_amount - wegld_fee_amount);
 
         return (registered_tokens, false);
     }

From 9b4a6698d3217a60cea05ed30dc4676df58e433e Mon Sep 17 00:00:00 2001
From: Andrei Baltariu <andreibaltariu1304@gmail.com>
Date: Thu, 4 Jul 2024 14:51:46 +0300
Subject: [PATCH 55/76] Regenerated proxy

---
 enshrine-esdt-safe/src/enshrine_esdt_safe_proxy.rs  | 13 ++++++++++++-
 .../wasm-enshrine-esdt-safe-full/src/lib.rs         |  5 +++--
 enshrine-esdt-safe/wasm/src/lib.rs                  |  5 +++--
 3 files changed, 18 insertions(+), 5 deletions(-)

diff --git a/enshrine-esdt-safe/src/enshrine_esdt_safe_proxy.rs b/enshrine-esdt-safe/src/enshrine_esdt_safe_proxy.rs
index 6a00ad9d..9557acd8 100644
--- a/enshrine-esdt-safe/src/enshrine_esdt_safe_proxy.rs
+++ b/enshrine-esdt-safe/src/enshrine_esdt_safe_proxy.rs
@@ -45,17 +45,20 @@ where
 {
     pub fn init<
         Arg0: ProxyArg<bool>,
-        Arg1: ProxyArg<OptionalValue<ManagedBuffer<Env::Api>>>,
+        Arg1: ProxyArg<Option<ManagedBuffer<Env::Api>>>,
+        Arg2: ProxyArg<Option<ManagedBuffer<Env::Api>>>,
     >(
         self,
         is_sovereign_chain: Arg0,
         wegld_identifier: Arg1,
+        sov_token_prefix: Arg2,
     ) -> TxTypedDeploy<Env, From, NotPayable, Gas, ()> {
         self.wrapped_tx
             .payment(NotPayable)
             .raw_deploy()
             .argument(&is_sovereign_chain)
             .argument(&wegld_identifier)
+            .argument(&sov_token_prefix)
             .original_result()
     }
 }
@@ -196,6 +199,14 @@ where
             .original_result()
     }
 
+    pub fn deposit_for_new_registrations(
+        self,
+    ) -> TxTypedCall<Env, From, To, (), Gas, ()> {
+        self.wrapped_tx
+            .raw_call("depositForNewRegistrations")
+            .original_result()
+    }
+
     pub fn set_max_tx_batch_size<
         Arg0: ProxyArg<usize>,
     >(
diff --git a/enshrine-esdt-safe/wasm-enshrine-esdt-safe-full/src/lib.rs b/enshrine-esdt-safe/wasm-enshrine-esdt-safe-full/src/lib.rs
index 08014062..65a944a9 100644
--- a/enshrine-esdt-safe/wasm-enshrine-esdt-safe-full/src/lib.rs
+++ b/enshrine-esdt-safe/wasm-enshrine-esdt-safe-full/src/lib.rs
@@ -6,10 +6,10 @@
 
 // Init:                                 1
 // Upgrade:                              1
-// Endpoints:                           28
+// Endpoints:                           29
 // Async Callback:                       1
 // Promise callbacks:                    1
-// Total number of exported functions:  32
+// Total number of exported functions:  33
 
 #![no_std]
 
@@ -29,6 +29,7 @@ multiversx_sc_wasm_adapter::endpoints! {
         removeSigners => remove_signers
         executeBridgeOps => execute_operations
         registerTokens => register_tokens
+        depositForNewRegistrations => deposit_for_new_registrations
         setMaxTxBatchSize => set_max_tx_batch_size
         setMaxTxBatchBlockDuration => set_max_tx_batch_block_duration
         getCurrentTxBatch => get_current_tx_batch
diff --git a/enshrine-esdt-safe/wasm/src/lib.rs b/enshrine-esdt-safe/wasm/src/lib.rs
index 08014062..65a944a9 100644
--- a/enshrine-esdt-safe/wasm/src/lib.rs
+++ b/enshrine-esdt-safe/wasm/src/lib.rs
@@ -6,10 +6,10 @@
 
 // Init:                                 1
 // Upgrade:                              1
-// Endpoints:                           28
+// Endpoints:                           29
 // Async Callback:                       1
 // Promise callbacks:                    1
-// Total number of exported functions:  32
+// Total number of exported functions:  33
 
 #![no_std]
 
@@ -29,6 +29,7 @@ multiversx_sc_wasm_adapter::endpoints! {
         removeSigners => remove_signers
         executeBridgeOps => execute_operations
         registerTokens => register_tokens
+        depositForNewRegistrations => deposit_for_new_registrations
         setMaxTxBatchSize => set_max_tx_batch_size
         setMaxTxBatchBlockDuration => set_max_tx_batch_block_duration
         getCurrentTxBatch => get_current_tx_batch

From f49be5122c30f60e0d6cec1405cbfc6b87cab353 Mon Sep 17 00:00:00 2001
From: Andrei Baltariu <andreibaltariu1304@gmail.com>
Date: Thu, 4 Jul 2024 18:33:27 +0300
Subject: [PATCH 56/76] Modified function to check sovereign prefix

---
 common/utils/src/lib.rs | 18 +++++++++++++++---
 1 file changed, 15 insertions(+), 3 deletions(-)

diff --git a/common/utils/src/lib.rs b/common/utils/src/lib.rs
index 371d2d75..5432834d 100644
--- a/common/utils/src/lib.rs
+++ b/common/utils/src/lib.rs
@@ -81,10 +81,22 @@ pub trait UtilsModule: bls_signature::BlsSignatureModule {
         false
     }
 
-    #[inline]
-    fn has_sov_prefix(&self, token_id: &TokenIdentifier, sov_prefix: ManagedBuffer) -> bool {
+    fn has_sov_prefix(&self, token_id: &TokenIdentifier, chain_prefix: ManagedBuffer) -> bool {
         require!(self.has_prefix(token_id), "Token does not have prefix");
 
-        *token_id == TokenIdentifier::from(sov_prefix)
+        let dash = b'-';
+        let buffer = token_id.as_managed_buffer();
+        let mut array_buffer = [0u8; 32];
+        let slice = buffer.load_to_byte_array(&mut array_buffer);
+
+        if let Some(index) = slice.iter().position(|&b| b == dash) {
+            let prefix = ManagedBuffer::from(&slice[..index]);
+
+            if prefix == chain_prefix {
+                return true;
+            }
+        }
+
+        false
     }
 }

From 0a6a31f1e9a74fc04830010aa32c18381c3e39da Mon Sep 17 00:00:00 2001
From: Andrei Baltariu <andreibaltariu1304@gmail.com>
Date: Thu, 4 Jul 2024 18:34:31 +0300
Subject: [PATCH 57/76] Renamed sovereign token mapper

---
 enshrine-esdt-safe/src/common/storage.rs                 | 2 +-
 enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs | 2 +-
 enshrine-esdt-safe/src/lib.rs                            | 2 +-
 enshrine-esdt-safe/src/to_sovereign/create_tx.rs         | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/enshrine-esdt-safe/src/common/storage.rs b/enshrine-esdt-safe/src/common/storage.rs
index 331e4de6..8153b9f2 100644
--- a/enshrine-esdt-safe/src/common/storage.rs
+++ b/enshrine-esdt-safe/src/common/storage.rs
@@ -9,5 +9,5 @@ pub trait CommonStorage {
     fn wegld_identifier(&self) -> SingleValueMapper<TokenIdentifier>;
 
     #[storage_mapper("sovereignTokenPrefix")]
-    fn sovereign_token_prefix(&self) -> SingleValueMapper<ManagedBuffer>;
+    fn sovereign_tokens_prefix(&self) -> SingleValueMapper<ManagedBuffer>;
 }
diff --git a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
index 54797440..00b8ec57 100644
--- a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
+++ b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
@@ -412,7 +412,7 @@ pub trait TransferTokensModule:
 
     #[inline]
     fn get_sovereign_prefix(&self) -> ManagedBuffer {
-        self.sovereign_token_prefix().get()
+        self.sovereign_tokens_prefix().get()
     }
 
     #[inline]
diff --git a/enshrine-esdt-safe/src/lib.rs b/enshrine-esdt-safe/src/lib.rs
index 3411d77e..e45e1d85 100644
--- a/enshrine-esdt-safe/src/lib.rs
+++ b/enshrine-esdt-safe/src/lib.rs
@@ -39,7 +39,7 @@ pub trait EnshrineEsdtSafe:
                     let identifier = TokenIdentifier::from(ticker);
                     if identifier.is_valid_esdt_identifier() {
                         self.wegld_identifier().set(identifier);
-                        self.sovereign_token_prefix().set(prefix);
+                        self.sovereign_tokens_prefix().set(prefix);
                     }
                 }
                 (Some(_), None) => {
diff --git a/enshrine-esdt-safe/src/to_sovereign/create_tx.rs b/enshrine-esdt-safe/src/to_sovereign/create_tx.rs
index 59d0f9ae..4f18b76d 100644
--- a/enshrine-esdt-safe/src/to_sovereign/create_tx.rs
+++ b/enshrine-esdt-safe/src/to_sovereign/create_tx.rs
@@ -69,7 +69,7 @@ pub trait CreateTxModule:
 
             current_token_data.amount = payment.amount.clone();
 
-            if self.is_sovereign_chain().get() || self.has_prefix(&payment.token_identifier) {
+            if self.is_sovereign_chain().get() || self.has_sov_prefix(&payment.token_identifier) {
                 self.send().esdt_local_burn(
                     &payment.token_identifier,
                     payment.token_nonce,

From 62aa434104a49ecd63d862061ad3ac6dcc26e656 Mon Sep 17 00:00:00 2001
From: Andrei Baltariu <andreibaltariu1304@gmail.com>
Date: Thu, 4 Jul 2024 18:42:34 +0300
Subject: [PATCH 58/76] Modified wegld fee and mint & burn logic

---
 .../src/from_sovereign/transfer_tokens.rs     | 27 +++++++++----------
 1 file changed, 13 insertions(+), 14 deletions(-)

diff --git a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
index 00b8ec57..042a1c2e 100644
--- a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
+++ b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
@@ -129,11 +129,11 @@ pub trait TransferTokensModule:
                 }
             }
 
-            return (tokens, false);
+            return (tokens, true);
         };
 
-        if wegld_position >= 0 && tokens.len() == 1 {
-            return (tokens, false);
+        if tokens.len() == 1 {
+            return (tokens, true);
         }
 
         let mut unregistered_tokens: ManagedVec<TokenIdentifier> = ManagedVec::new();
@@ -162,7 +162,7 @@ pub trait TransferTokensModule:
 
         self.refund_wegld(sender, wegld_amount - wegld_fee_amount);
 
-        return (registered_tokens, false);
+        return (registered_tokens, true);
     }
 
     fn refund_wegld(&self, sender: &ManagedAddress<Self::Api>, wegld_amount: BigUint<Self::Api>) {
@@ -181,10 +181,7 @@ pub trait TransferTokensModule:
         let mut output_payments = ManagedVec::new();
 
         for operation_token in operation_tokens.iter() {
-            if !self.has_sov_prefix(
-                &operation_token.token_identifier,
-                self.get_sovereign_prefix(),
-            ) {
+            if !self.has_prefix(&operation_token.token_identifier) {
                 output_payments.push(operation_token.clone());
                 continue;
             }
@@ -342,13 +339,15 @@ pub trait TransferTokensModule:
 
     fn burn_sovereign_tokens(&self, operation: &Operation<Self::Api>) {
         for token in operation.tokens.iter() {
-            if self.has_sov_prefix(&token.token_identifier, self.get_sovereign_prefix()) {
-                self.send().esdt_local_burn(
-                    &token.token_identifier,
-                    token.token_nonce,
-                    &token.token_data.amount,
-                );
+            if self.has_prefix(&token.token_identifier) {
+                continue;
             }
+
+            self.send().esdt_local_burn(
+                &token.token_identifier,
+                token.token_nonce,
+                &token.token_data.amount,
+            );
         }
     }
 

From 7f058e61dee36e2d1d34034f3e3973416bf928f0 Mon Sep 17 00:00:00 2001
From: Andrei Baltariu <andreibaltariu1304@gmail.com>
Date: Thu, 4 Jul 2024 18:51:36 +0300
Subject: [PATCH 59/76] Separated lib.rs match statement

---
 enshrine-esdt-safe/src/lib.rs | 31 ++++++++++++++++---------------
 1 file changed, 16 insertions(+), 15 deletions(-)

diff --git a/enshrine-esdt-safe/src/lib.rs b/enshrine-esdt-safe/src/lib.rs
index e45e1d85..2064b71e 100644
--- a/enshrine-esdt-safe/src/lib.rs
+++ b/enshrine-esdt-safe/src/lib.rs
@@ -34,23 +34,24 @@ pub trait EnshrineEsdtSafe:
         self.set_paused(true);
 
         if !is_sovereign_chain {
-            match (wegld_identifier, sov_token_prefix) {
-                (Some(ticker), Some(prefix)) => {
+            match wegld_identifier {
+                Some(ticker) => {
                     let identifier = TokenIdentifier::from(ticker);
-                    if identifier.is_valid_esdt_identifier() {
-                        self.wegld_identifier().set(identifier);
-                        self.sovereign_tokens_prefix().set(prefix);
-                    }
-                }
-                (Some(_), None) => {
-                    sc_panic!("Sovereign Token Prefix must be set in Mainchain")
-                }
-                (None, Some(_)) => {
-                    sc_panic!("WEGLG identifier must be set in Mainchain")
+
+                    require!(
+                        identifier.is_valid_esdt_identifier(),
+                        "Sent Identifier is not valid"
+                    );
+
+                    self.wegld_identifier().set(identifier);
                 }
-                _ => sc_panic!(
-                    "Both WEGLD identifier and Sovereign Token Prefix must be set in Mainchain"
-                ),
+
+                None => sc_panic!("WEGLG identifier must be set in Mainchain"),
+            }
+
+            match sov_token_prefix {
+                Some(prefix) => self.sovereign_tokens_prefix().set(prefix),
+                None => sc_panic!("Sovereign Token Prefix must be set in Mainchain"),
             }
         }
     }

From 906fb920ac952f057ccf7bde87251e44563e8e51 Mon Sep 17 00:00:00 2001
From: Andrei Baltariu <andreibaltariu1304@gmail.com>
Date: Thu, 4 Jul 2024 18:53:45 +0300
Subject: [PATCH 60/76] Reverted create_tx file

---
 enshrine-esdt-safe/src/to_sovereign/create_tx.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/enshrine-esdt-safe/src/to_sovereign/create_tx.rs b/enshrine-esdt-safe/src/to_sovereign/create_tx.rs
index 4f18b76d..59d0f9ae 100644
--- a/enshrine-esdt-safe/src/to_sovereign/create_tx.rs
+++ b/enshrine-esdt-safe/src/to_sovereign/create_tx.rs
@@ -69,7 +69,7 @@ pub trait CreateTxModule:
 
             current_token_data.amount = payment.amount.clone();
 
-            if self.is_sovereign_chain().get() || self.has_sov_prefix(&payment.token_identifier) {
+            if self.is_sovereign_chain().get() || self.has_prefix(&payment.token_identifier) {
                 self.send().esdt_local_burn(
                     &payment.token_identifier,
                     payment.token_nonce,

From aaf36e77335620e3a1e151e6f88c5b09d58709a9 Mon Sep 17 00:00:00 2001
From: Andrei Baltariu <andreibaltariu1304@gmail.com>
Date: Fri, 5 Jul 2024 11:22:57 +0300
Subject: [PATCH 61/76] Modified mapper identifier and removed require

---
 enshrine-esdt-safe/src/common/storage.rs               |  2 +-
 .../src/from_sovereign/transfer_tokens.rs              | 10 ++++++----
 2 files changed, 7 insertions(+), 5 deletions(-)

diff --git a/enshrine-esdt-safe/src/common/storage.rs b/enshrine-esdt-safe/src/common/storage.rs
index 8153b9f2..37097f96 100644
--- a/enshrine-esdt-safe/src/common/storage.rs
+++ b/enshrine-esdt-safe/src/common/storage.rs
@@ -8,6 +8,6 @@ pub trait CommonStorage {
     #[storage_mapper("wegldIdentifier")]
     fn wegld_identifier(&self) -> SingleValueMapper<TokenIdentifier>;
 
-    #[storage_mapper("sovereignTokenPrefix")]
+    #[storage_mapper("sovereignTokensPrefix")]
     fn sovereign_tokens_prefix(&self) -> SingleValueMapper<ManagedBuffer>;
 }
diff --git a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
index 042a1c2e..f6a32e75 100644
--- a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
+++ b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
@@ -160,14 +160,16 @@ pub trait TransferTokensModule:
             self.register_token(token_identifier.clone_value());
         }
 
-        self.refund_wegld(sender, wegld_amount - wegld_fee_amount);
+        let remaining_wegld = wegld_amount - wegld_fee_amount;
+
+        if remaining_wegld > 0 {
+            self.refund_wegld(sender, remaining_wegld);
+        }
 
         return (registered_tokens, true);
     }
 
     fn refund_wegld(&self, sender: &ManagedAddress<Self::Api>, wegld_amount: BigUint<Self::Api>) {
-        require!(wegld_amount > 0, "No WEGLD fee sent");
-
         let wegld_identifier = self.wegld_identifier().get();
         let payment = EsdtTokenPayment::new(wegld_identifier, 0, wegld_amount);
 
@@ -339,7 +341,7 @@ pub trait TransferTokensModule:
 
     fn burn_sovereign_tokens(&self, operation: &Operation<Self::Api>) {
         for token in operation.tokens.iter() {
-            if self.has_prefix(&token.token_identifier) {
+            if !self.has_prefix(&token.token_identifier) {
                 continue;
             }
 

From 28736ebf3fdc5861228d3509e70191a5c84729b5 Mon Sep 17 00:00:00 2001
From: Andrei Baltariu <andreibaltariu1304@gmail.com>
Date: Fri, 5 Jul 2024 13:02:09 +0300
Subject: [PATCH 62/76] Called has_sov_prefix instead of has_prefix

---
 enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
index f6a32e75..76e42ab2 100644
--- a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
+++ b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
@@ -183,7 +183,8 @@ pub trait TransferTokensModule:
         let mut output_payments = ManagedVec::new();
 
         for operation_token in operation_tokens.iter() {
-            if !self.has_prefix(&operation_token.token_identifier) {
+            let sov_prefix = self.get_sovereign_prefix();
+            if !self.has_sov_prefix(&operation_token.token_identifier, sov_prefix) {
                 output_payments.push(operation_token.clone());
                 continue;
             }
@@ -341,7 +342,8 @@ pub trait TransferTokensModule:
 
     fn burn_sovereign_tokens(&self, operation: &Operation<Self::Api>) {
         for token in operation.tokens.iter() {
-            if !self.has_prefix(&token.token_identifier) {
+            let sov_prefix = self.get_sovereign_prefix();
+            if !self.has_sov_prefix(&token.token_identifier, sov_prefix) {
                 continue;
             }
 

From 5d3b2f463e4b33d44e6a7dddbe54e7b1a786d429 Mon Sep 17 00:00:00 2001
From: Andrei Baltariu <andreibaltariu1304@gmail.com>
Date: Fri, 5 Jul 2024 13:16:14 +0300
Subject: [PATCH 63/76] Modified token verification logic Now the verification
 consists only if the tokens has the current's sovereign prefix and if they
 are registered. The WEGLD fee has to be paid before execution.

---
 .../src/from_sovereign/transfer_tokens.rs     | 95 ++-----------------
 1 file changed, 10 insertions(+), 85 deletions(-)

diff --git a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
index 76e42ab2..3247c1a8 100644
--- a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
+++ b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
@@ -39,24 +39,20 @@ pub trait TransferTokensModule:
             sc_panic!("Operation is not registered");
         }
 
-        let (remaining_tokens, is_wegld_fee_paid) = self.verify_operation_tokens_for_issue_fee(
-            &operation.data.op_sender,
-            operation.tokens.clone(),
-        );
+        let are_tokens_registered =
+            self.verify_operation_tokens_issue_paid(operation.tokens.clone());
 
-        if !is_wegld_fee_paid {
+        if !are_tokens_registered {
             self.emit_transfer_failed_events(
                 &hash_of_hashes,
                 &OperationTuple {
-                    op_hash: operation_hash,
-                    operation,
+                    op_hash: operation_hash.clone(),
+                    operation: operation.clone(),
                 },
             );
-
-            sc_panic!("Not enough WEGLD to register all tokens");
         }
 
-        let minted_operation_tokens = self.mint_tokens(&remaining_tokens);
+        let minted_operation_tokens = self.mint_tokens(&operation.tokens);
         let operation_tuple = OperationTuple {
             op_hash: operation_hash.clone(),
             operation: operation.clone(),
@@ -90,90 +86,19 @@ pub trait TransferTokensModule:
         }
     }
 
-    #[endpoint(depositForNewRegistrations)]
-    #[payable("*")]
-    fn deposit_for_new_registrations(&self) {
-        let call_value = self.call_value().single_esdt();
-
-        require!(
-            call_value.amount >= DEFAULT_ISSUE_COST,
-            "The minimum amount of WEGLD wasn't met"
-        );
-    }
-
-    fn get_wegld_payment_info(
-        &self,
-        tokens: &ManagedVec<OperationEsdtPayment<Self::Api>>,
-    ) -> (BigUint, isize) {
-        for (i, token) in tokens.iter().enumerate() {
-            if self.is_wegld(&token.token_identifier) {
-                return (token.token_data.amount, i as isize);
-            }
-        }
-
-        (BigUint::from(0u32), -1)
-    }
-
-    fn verify_operation_tokens_for_issue_fee(
+    fn verify_operation_tokens_issue_paid(
         &self,
-        sender: &ManagedAddress<Self::Api>,
         tokens: ManagedVec<OperationEsdtPayment<Self::Api>>,
-    ) -> (ManagedVec<OperationEsdtPayment<Self::Api>>, bool) {
+    ) -> bool {
         require!(!tokens.is_empty(), "Tokens array should not be empty");
-        let (wegld_amount, wegld_position) = self.get_wegld_payment_info(&tokens);
-
-        if wegld_position == -1 {
-            for token in tokens.iter() {
-                if !self.was_token_registered(&token.token_identifier) {
-                    return (ManagedVec::new(), false);
-                }
-            }
-
-            return (tokens, true);
-        };
-
-        if tokens.len() == 1 {
-            return (tokens, true);
-        }
-
-        let mut unregistered_tokens: ManagedVec<TokenIdentifier> = ManagedVec::new();
 
         for token in tokens.iter() {
             if !self.was_token_registered(&token.token_identifier) {
-                unregistered_tokens.push(token.token_identifier);
+                return false;
             }
         }
 
-        if unregistered_tokens.is_empty() {
-            return (tokens, true);
-        }
-
-        let wegld_fee_amount = BigUint::from(DEFAULT_ISSUE_COST * unregistered_tokens.len() as u64);
-        let mut registered_tokens = tokens;
-        registered_tokens.remove(wegld_position as usize);
-
-        if wegld_amount < wegld_fee_amount {
-            return (ManagedVec::new(), false);
-        }
-
-        for token_identifier in unregistered_tokens.iter() {
-            self.register_token(token_identifier.clone_value());
-        }
-
-        let remaining_wegld = wegld_amount - wegld_fee_amount;
-
-        if remaining_wegld > 0 {
-            self.refund_wegld(sender, remaining_wegld);
-        }
-
-        return (registered_tokens, true);
-    }
-
-    fn refund_wegld(&self, sender: &ManagedAddress<Self::Api>, wegld_amount: BigUint<Self::Api>) {
-        let wegld_identifier = self.wegld_identifier().get();
-        let payment = EsdtTokenPayment::new(wegld_identifier, 0, wegld_amount);
-
-        self.tx().to(sender).esdt(payment).transfer();
+        true
     }
 
     fn mint_tokens(

From ff22b99c99253eb11d7bf6795b65d7e72ec54ebe Mon Sep 17 00:00:00 2001
From: Andrei Baltariu <andreibaltariu1304@gmail.com>
Date: Fri, 5 Jul 2024 13:20:43 +0300
Subject: [PATCH 64/76] Regenerated proxy

---
 enshrine-esdt-safe/src/enshrine_esdt_safe_proxy.rs        | 8 --------
 .../wasm-enshrine-esdt-safe-full/src/lib.rs               | 5 ++---
 enshrine-esdt-safe/wasm/src/lib.rs                        | 5 ++---
 3 files changed, 4 insertions(+), 14 deletions(-)

diff --git a/enshrine-esdt-safe/src/enshrine_esdt_safe_proxy.rs b/enshrine-esdt-safe/src/enshrine_esdt_safe_proxy.rs
index 9557acd8..abaec97f 100644
--- a/enshrine-esdt-safe/src/enshrine_esdt_safe_proxy.rs
+++ b/enshrine-esdt-safe/src/enshrine_esdt_safe_proxy.rs
@@ -199,14 +199,6 @@ where
             .original_result()
     }
 
-    pub fn deposit_for_new_registrations(
-        self,
-    ) -> TxTypedCall<Env, From, To, (), Gas, ()> {
-        self.wrapped_tx
-            .raw_call("depositForNewRegistrations")
-            .original_result()
-    }
-
     pub fn set_max_tx_batch_size<
         Arg0: ProxyArg<usize>,
     >(
diff --git a/enshrine-esdt-safe/wasm-enshrine-esdt-safe-full/src/lib.rs b/enshrine-esdt-safe/wasm-enshrine-esdt-safe-full/src/lib.rs
index 65a944a9..08014062 100644
--- a/enshrine-esdt-safe/wasm-enshrine-esdt-safe-full/src/lib.rs
+++ b/enshrine-esdt-safe/wasm-enshrine-esdt-safe-full/src/lib.rs
@@ -6,10 +6,10 @@
 
 // Init:                                 1
 // Upgrade:                              1
-// Endpoints:                           29
+// Endpoints:                           28
 // Async Callback:                       1
 // Promise callbacks:                    1
-// Total number of exported functions:  33
+// Total number of exported functions:  32
 
 #![no_std]
 
@@ -29,7 +29,6 @@ multiversx_sc_wasm_adapter::endpoints! {
         removeSigners => remove_signers
         executeBridgeOps => execute_operations
         registerTokens => register_tokens
-        depositForNewRegistrations => deposit_for_new_registrations
         setMaxTxBatchSize => set_max_tx_batch_size
         setMaxTxBatchBlockDuration => set_max_tx_batch_block_duration
         getCurrentTxBatch => get_current_tx_batch
diff --git a/enshrine-esdt-safe/wasm/src/lib.rs b/enshrine-esdt-safe/wasm/src/lib.rs
index 65a944a9..08014062 100644
--- a/enshrine-esdt-safe/wasm/src/lib.rs
+++ b/enshrine-esdt-safe/wasm/src/lib.rs
@@ -6,10 +6,10 @@
 
 // Init:                                 1
 // Upgrade:                              1
-// Endpoints:                           29
+// Endpoints:                           28
 // Async Callback:                       1
 // Promise callbacks:                    1
-// Total number of exported functions:  33
+// Total number of exported functions:  32
 
 #![no_std]
 
@@ -29,7 +29,6 @@ multiversx_sc_wasm_adapter::endpoints! {
         removeSigners => remove_signers
         executeBridgeOps => execute_operations
         registerTokens => register_tokens
-        depositForNewRegistrations => deposit_for_new_registrations
         setMaxTxBatchSize => set_max_tx_batch_size
         setMaxTxBatchBlockDuration => set_max_tx_batch_block_duration
         getCurrentTxBatch => get_current_tx_batch

From 13e4765065683d379e8e7013ab2e812a3376accd Mon Sep 17 00:00:00 2001
From: Andrei Baltariu <andreibaltariu1304@gmail.com>
Date: Fri, 5 Jul 2024 15:00:56 +0300
Subject: [PATCH 65/76] Renamed endpoint

---
 enshrine-esdt-safe/src/enshrine_esdt_safe_proxy.rs         | 4 ++--
 enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs   | 4 ++--
 enshrine-esdt-safe/wasm-enshrine-esdt-safe-full/src/lib.rs | 2 +-
 enshrine-esdt-safe/wasm/src/lib.rs                         | 2 +-
 4 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/enshrine-esdt-safe/src/enshrine_esdt_safe_proxy.rs b/enshrine-esdt-safe/src/enshrine_esdt_safe_proxy.rs
index abaec97f..54425666 100644
--- a/enshrine-esdt-safe/src/enshrine_esdt_safe_proxy.rs
+++ b/enshrine-esdt-safe/src/enshrine_esdt_safe_proxy.rs
@@ -187,14 +187,14 @@ where
             .original_result()
     }
 
-    pub fn register_tokens<
+    pub fn register_new_token_id<
         Arg0: ProxyArg<MultiValueEncoded<Env::Api, TokenIdentifier<Env::Api>>>,
     >(
         self,
         tokens: Arg0,
     ) -> TxTypedCall<Env, From, To, (), Gas, ()> {
         self.wrapped_tx
-            .raw_call("registerTokens")
+            .raw_call("registerNewTokenID")
             .argument(&tokens)
             .original_result()
     }
diff --git a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
index 3247c1a8..24ee0238 100644
--- a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
+++ b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
@@ -65,9 +65,9 @@ pub trait TransferTokensModule:
         );
     }
 
-    #[endpoint(registerTokens)]
+    #[endpoint(registerNewTokenID)]
     #[payable("*")]
-    fn register_tokens(&self, tokens: MultiValueEncoded<TokenIdentifier>) {
+    fn register_new_token_id(&self, tokens: MultiValueEncoded<TokenIdentifier>) {
         let call_payment = self.call_value().single_esdt().clone();
         let wegld_identifier = self.wegld_identifier().get();
 
diff --git a/enshrine-esdt-safe/wasm-enshrine-esdt-safe-full/src/lib.rs b/enshrine-esdt-safe/wasm-enshrine-esdt-safe-full/src/lib.rs
index 08014062..d7a87d6b 100644
--- a/enshrine-esdt-safe/wasm-enshrine-esdt-safe-full/src/lib.rs
+++ b/enshrine-esdt-safe/wasm-enshrine-esdt-safe-full/src/lib.rs
@@ -28,7 +28,7 @@ multiversx_sc_wasm_adapter::endpoints! {
         addSigners => add_signers
         removeSigners => remove_signers
         executeBridgeOps => execute_operations
-        registerTokens => register_tokens
+        registerNewTokenID => register_new_token_id
         setMaxTxBatchSize => set_max_tx_batch_size
         setMaxTxBatchBlockDuration => set_max_tx_batch_block_duration
         getCurrentTxBatch => get_current_tx_batch
diff --git a/enshrine-esdt-safe/wasm/src/lib.rs b/enshrine-esdt-safe/wasm/src/lib.rs
index 08014062..d7a87d6b 100644
--- a/enshrine-esdt-safe/wasm/src/lib.rs
+++ b/enshrine-esdt-safe/wasm/src/lib.rs
@@ -28,7 +28,7 @@ multiversx_sc_wasm_adapter::endpoints! {
         addSigners => add_signers
         removeSigners => remove_signers
         executeBridgeOps => execute_operations
-        registerTokens => register_tokens
+        registerNewTokenID => register_new_token_id
         setMaxTxBatchSize => set_max_tx_batch_size
         setMaxTxBatchBlockDuration => set_max_tx_batch_block_duration
         getCurrentTxBatch => get_current_tx_batch

From 13bac6a5ae040486e44440a528d86c94806a70f1 Mon Sep 17 00:00:00 2001
From: Andrei Baltariu <andreibaltariu1304@gmail.com>
Date: Fri, 5 Jul 2024 15:01:35 +0300
Subject: [PATCH 66/76] Removed require statement

---
 enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs | 2 --
 1 file changed, 2 deletions(-)

diff --git a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
index 24ee0238..21644154 100644
--- a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
+++ b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
@@ -90,8 +90,6 @@ pub trait TransferTokensModule:
         &self,
         tokens: ManagedVec<OperationEsdtPayment<Self::Api>>,
     ) -> bool {
-        require!(!tokens.is_empty(), "Tokens array should not be empty");
-
         for token in tokens.iter() {
             if !self.was_token_registered(&token.token_identifier) {
                 return false;

From 5db58c695e72a808dcefc430c4c1fd217564f79d Mon Sep 17 00:00:00 2001
From: Andrei Baltariu <andreibaltariu1304@gmail.com>
Date: Mon, 8 Jul 2024 13:12:14 +0300
Subject: [PATCH 67/76] Added panic in execute operations

---
 enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
index 21644154..476e1249 100644
--- a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
+++ b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
@@ -50,6 +50,8 @@ pub trait TransferTokensModule:
                     operation: operation.clone(),
                 },
             );
+
+            sc_panic!("One or more tokens are not registered");
         }
 
         let minted_operation_tokens = self.mint_tokens(&operation.tokens);

From 98e86fdca3ab3db7f5a0d0f4f33029413a3dcbae Mon Sep 17 00:00:00 2001
From: Andrei Baltariu <andreibaltariu1304@gmail.com>
Date: Mon, 8 Jul 2024 15:51:57 +0300
Subject: [PATCH 68/76] Modified init argument

---
 enshrine-esdt-safe/src/enshrine_esdt_safe_proxy.rs | 2 +-
 enshrine-esdt-safe/src/lib.rs                      | 6 ++----
 2 files changed, 3 insertions(+), 5 deletions(-)

diff --git a/enshrine-esdt-safe/src/enshrine_esdt_safe_proxy.rs b/enshrine-esdt-safe/src/enshrine_esdt_safe_proxy.rs
index 54425666..e7be6902 100644
--- a/enshrine-esdt-safe/src/enshrine_esdt_safe_proxy.rs
+++ b/enshrine-esdt-safe/src/enshrine_esdt_safe_proxy.rs
@@ -45,7 +45,7 @@ where
 {
     pub fn init<
         Arg0: ProxyArg<bool>,
-        Arg1: ProxyArg<Option<ManagedBuffer<Env::Api>>>,
+        Arg1: ProxyArg<Option<TokenIdentifier<Env::Api>>>,
         Arg2: ProxyArg<Option<ManagedBuffer<Env::Api>>>,
     >(
         self,
diff --git a/enshrine-esdt-safe/src/lib.rs b/enshrine-esdt-safe/src/lib.rs
index 2064b71e..b3472a1c 100644
--- a/enshrine-esdt-safe/src/lib.rs
+++ b/enshrine-esdt-safe/src/lib.rs
@@ -27,7 +27,7 @@ pub trait EnshrineEsdtSafe:
     fn init(
         &self,
         is_sovereign_chain: bool,
-        wegld_identifier: Option<ManagedBuffer>,
+        wegld_identifier: Option<TokenIdentifier>,
         sov_token_prefix: Option<ManagedBuffer>,
     ) {
         self.is_sovereign_chain().set(is_sovereign_chain);
@@ -35,9 +35,7 @@ pub trait EnshrineEsdtSafe:
 
         if !is_sovereign_chain {
             match wegld_identifier {
-                Some(ticker) => {
-                    let identifier = TokenIdentifier::from(ticker);
-
+                Some(identifier) => {
                     require!(
                         identifier.is_valid_esdt_identifier(),
                         "Sent Identifier is not valid"

From db647b9145089fed5da4f976a1be5924b748b66f Mon Sep 17 00:00:00 2001
From: Andrei Baltariu <andreibaltariu1304@gmail.com>
Date: Tue, 9 Jul 2024 10:27:02 +0300
Subject: [PATCH 69/76] Removed sc_panic and added return

---
 enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
index 476e1249..c31144b7 100644
--- a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
+++ b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
@@ -51,7 +51,7 @@ pub trait TransferTokensModule:
                 },
             );
 
-            sc_panic!("One or more tokens are not registered");
+            return;
         }
 
         let minted_operation_tokens = self.mint_tokens(&operation.tokens);

From a8ddcc8c02c96295915000b689d349359a561300 Mon Sep 17 00:00:00 2001
From: Andrei Baltariu <andreibaltariu1304@gmail.com>
Date: Tue, 9 Jul 2024 15:16:58 +0300
Subject: [PATCH 70/76] Modified tokens wegld registration and removed function

---
 .../src/from_sovereign/transfer_tokens.rs          | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
index c31144b7..30bf4715 100644
--- a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
+++ b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
@@ -92,8 +92,14 @@ pub trait TransferTokensModule:
         &self,
         tokens: ManagedVec<OperationEsdtPayment<Self::Api>>,
     ) -> bool {
+        let sovereign_prefix = self.get_sovereign_prefix();
+
         for token in tokens.iter() {
-            if !self.was_token_registered(&token.token_identifier) {
+            if !self.has_sov_prefix(&token.token_identifier, sovereign_prefix) {
+                continue;
+            }
+
+            if !self.paid_issued_tokens().contains(&token.token_identifier) {
                 return false;
             }
         }
@@ -332,12 +338,6 @@ pub trait TransferTokensModule:
         }
     }
 
-    #[inline]
-    fn was_token_registered(&self, token_id: &TokenIdentifier<Self::Api>) -> bool {
-        self.has_sov_prefix(token_id, self.get_sovereign_prefix())
-            && self.paid_issued_tokens().contains(token_id)
-    }
-
     #[inline]
     fn get_sovereign_prefix(&self) -> ManagedBuffer {
         self.sovereign_tokens_prefix().get()

From 5882849a4df453d4b4f7714d1d9adfebf35ae818 Mon Sep 17 00:00:00 2001
From: Andrei Baltariu <andreibaltariu1304@gmail.com>
Date: Tue, 9 Jul 2024 15:21:26 +0300
Subject: [PATCH 71/76] Modified get_sovereign_prefix call

---
 enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
index 30bf4715..df28fad1 100644
--- a/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
+++ b/enshrine-esdt-safe/src/from_sovereign/transfer_tokens.rs
@@ -92,10 +92,8 @@ pub trait TransferTokensModule:
         &self,
         tokens: ManagedVec<OperationEsdtPayment<Self::Api>>,
     ) -> bool {
-        let sovereign_prefix = self.get_sovereign_prefix();
-
         for token in tokens.iter() {
-            if !self.has_sov_prefix(&token.token_identifier, sovereign_prefix) {
+            if !self.has_sov_prefix(&token.token_identifier, self.get_sovereign_prefix()) {
                 continue;
             }
 

From 6aef775cb4173c2917b80fa264a0354bb4b51000 Mon Sep 17 00:00:00 2001
From: Andrei Baltariu <andreibaltariu1304@gmail.com>
Date: Wed, 10 Jul 2024 09:27:15 +0300
Subject: [PATCH 72/76] Removed require and added if

---
 common/utils/src/lib.rs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/common/utils/src/lib.rs b/common/utils/src/lib.rs
index 5432834d..e8a318f9 100644
--- a/common/utils/src/lib.rs
+++ b/common/utils/src/lib.rs
@@ -82,7 +82,9 @@ pub trait UtilsModule: bls_signature::BlsSignatureModule {
     }
 
     fn has_sov_prefix(&self, token_id: &TokenIdentifier, chain_prefix: ManagedBuffer) -> bool {
-        require!(self.has_prefix(token_id), "Token does not have prefix");
+        if !self.has_prefix(token_id) {
+            return false;
+        }
 
         let dash = b'-';
         let buffer = token_id.as_managed_buffer();

From f660493b807fa47cf4ad4ff19cc5ef0dc1497f5a Mon Sep 17 00:00:00 2001
From: Andrei Baltariu <andreibaltariu1304@gmail.com>
Date: Thu, 11 Jul 2024 10:46:30 +0300
Subject: [PATCH 73/76] Added constants for prefix checks

---
 common/utils/src/lib.rs | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/common/utils/src/lib.rs b/common/utils/src/lib.rs
index e8a318f9..4f53c016 100644
--- a/common/utils/src/lib.rs
+++ b/common/utils/src/lib.rs
@@ -7,6 +7,8 @@ multiversx_sc::imports!();
 pub type PaymentsVec<M> = ManagedVec<M, EsdtTokenPayment<M>>;
 
 static ERR_EMPTY_PAYMENTS: &[u8] = b"No payments";
+const DASH: u8 = b'-';
+const MAX_TOKEN_ID_LEN: usize = 32;
 
 #[multiversx_sc::module]
 pub trait UtilsModule: bls_signature::BlsSignatureModule {
@@ -67,12 +69,11 @@ pub trait UtilsModule: bls_signature::BlsSignatureModule {
     }
 
     fn has_prefix(&self, token_id: &TokenIdentifier) -> bool {
-        let dash = b'-';
         let buffer = token_id.as_managed_buffer();
-        let mut array_buffer = [0u8; 32];
+        let mut array_buffer = [0u8; MAX_TOKEN_ID_LEN];
         let slice = buffer.load_to_byte_array(&mut array_buffer);
 
-        let counter = slice.iter().filter(|&&c| c == dash).count();
+        let counter = slice.iter().filter(|&&c| c == DASH).count();
 
         if counter == 2 {
             return true;
@@ -86,12 +87,11 @@ pub trait UtilsModule: bls_signature::BlsSignatureModule {
             return false;
         }
 
-        let dash = b'-';
         let buffer = token_id.as_managed_buffer();
-        let mut array_buffer = [0u8; 32];
+        let mut array_buffer = [0u8; MAX_TOKEN_ID_LEN];
         let slice = buffer.load_to_byte_array(&mut array_buffer);
 
-        if let Some(index) = slice.iter().position(|&b| b == dash) {
+        if let Some(index) = slice.iter().position(|&b| b == DASH) {
             let prefix = ManagedBuffer::from(&slice[..index]);
 
             if prefix == chain_prefix {

From 9ad4b0e2a7a3f0a96c6424c7ad7809ce6bbf3797 Mon Sep 17 00:00:00 2001
From: Andrei Baltariu <andreibaltariu1304@gmail.com>
Date: Thu, 11 Jul 2024 20:22:06 +0300
Subject: [PATCH 74/76] Modified init endpoint if condition

---
 enshrine-esdt-safe/src/lib.rs | 30 ++++++++++++++++--------------
 1 file changed, 16 insertions(+), 14 deletions(-)

diff --git a/enshrine-esdt-safe/src/lib.rs b/enshrine-esdt-safe/src/lib.rs
index b3472a1c..7f7558f9 100644
--- a/enshrine-esdt-safe/src/lib.rs
+++ b/enshrine-esdt-safe/src/lib.rs
@@ -33,24 +33,26 @@ pub trait EnshrineEsdtSafe:
         self.is_sovereign_chain().set(is_sovereign_chain);
         self.set_paused(true);
 
-        if !is_sovereign_chain {
-            match wegld_identifier {
-                Some(identifier) => {
-                    require!(
-                        identifier.is_valid_esdt_identifier(),
-                        "Sent Identifier is not valid"
-                    );
+        if is_sovereign_chain {
+            return;
+        }
 
-                    self.wegld_identifier().set(identifier);
-                }
+        match wegld_identifier {
+            Some(identifier) => {
+                require!(
+                    identifier.is_valid_esdt_identifier(),
+                    "Sent Identifier is not valid"
+                );
 
-                None => sc_panic!("WEGLG identifier must be set in Mainchain"),
+                self.wegld_identifier().set(identifier);
             }
 
-            match sov_token_prefix {
-                Some(prefix) => self.sovereign_tokens_prefix().set(prefix),
-                None => sc_panic!("Sovereign Token Prefix must be set in Mainchain"),
-            }
+            None => sc_panic!("WEGLG identifier must be set in Mainchain"),
+        }
+
+        match sov_token_prefix {
+            Some(prefix) => self.sovereign_tokens_prefix().set(prefix),
+            None => sc_panic!("Sovereign Token Prefix must be set in Mainchain"),
         }
     }
 

From 67856273829bbe60bc32eb76b6ec081a2aba16ce Mon Sep 17 00:00:00 2001
From: Andrei Baltariu <andreibaltariu1304@gmail.com>
Date: Fri, 12 Jul 2024 10:26:17 +0300
Subject: [PATCH 75/76] Renamed optional parameters in init

---
 enshrine-esdt-safe/src/lib.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/enshrine-esdt-safe/src/lib.rs b/enshrine-esdt-safe/src/lib.rs
index 7f7558f9..4b0820e9 100644
--- a/enshrine-esdt-safe/src/lib.rs
+++ b/enshrine-esdt-safe/src/lib.rs
@@ -27,8 +27,8 @@ pub trait EnshrineEsdtSafe:
     fn init(
         &self,
         is_sovereign_chain: bool,
-        wegld_identifier: Option<TokenIdentifier>,
-        sov_token_prefix: Option<ManagedBuffer>,
+        opt_wegld_identifier: Option<TokenIdentifier>,
+        opt_sov_token_prefix: Option<ManagedBuffer>,
     ) {
         self.is_sovereign_chain().set(is_sovereign_chain);
         self.set_paused(true);
@@ -37,7 +37,7 @@ pub trait EnshrineEsdtSafe:
             return;
         }
 
-        match wegld_identifier {
+        match opt_wegld_identifier {
             Some(identifier) => {
                 require!(
                     identifier.is_valid_esdt_identifier(),
@@ -50,7 +50,7 @@ pub trait EnshrineEsdtSafe:
             None => sc_panic!("WEGLG identifier must be set in Mainchain"),
         }
 
-        match sov_token_prefix {
+        match opt_sov_token_prefix {
             Some(prefix) => self.sovereign_tokens_prefix().set(prefix),
             None => sc_panic!("Sovereign Token Prefix must be set in Mainchain"),
         }

From 4b92c046050660cf7013eb1fef6c3cebebe463f6 Mon Sep 17 00:00:00 2001
From: Andrei Baltariu <andreibaltariu1304@gmail.com>
Date: Fri, 12 Jul 2024 10:28:30 +0300
Subject: [PATCH 76/76] Regenerated proxy

---
 enshrine-esdt-safe/src/enshrine_esdt_safe_proxy.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/enshrine-esdt-safe/src/enshrine_esdt_safe_proxy.rs b/enshrine-esdt-safe/src/enshrine_esdt_safe_proxy.rs
index e7be6902..54b2b2ff 100644
--- a/enshrine-esdt-safe/src/enshrine_esdt_safe_proxy.rs
+++ b/enshrine-esdt-safe/src/enshrine_esdt_safe_proxy.rs
@@ -50,15 +50,15 @@ where
     >(
         self,
         is_sovereign_chain: Arg0,
-        wegld_identifier: Arg1,
-        sov_token_prefix: Arg2,
+        opt_wegld_identifier: Arg1,
+        opt_sov_token_prefix: Arg2,
     ) -> TxTypedDeploy<Env, From, NotPayable, Gas, ()> {
         self.wrapped_tx
             .payment(NotPayable)
             .raw_deploy()
             .argument(&is_sovereign_chain)
-            .argument(&wegld_identifier)
-            .argument(&sov_token_prefix)
+            .argument(&opt_wegld_identifier)
+            .argument(&opt_sov_token_prefix)
             .original_result()
     }
 }