Merge pull request #36 from multiversx/alpha/fee-market

Alpha Sovereign SCs

Cargo.toml

@@ -7,5 +7,11 @@ members = [
   "esdt-safe",
   "esdt-safe/meta",
   "fee-market",
-  "fee-market/meta"
+  "fee-market/meta",
+  "pair-mock",
+  "pair-mock/meta",
+  "router-mock",
+  "router-mock/meta",
+  "multisigverifier",
+  "multisigverifier/meta", 
 ]

common/transaction/src/lib.rs

@@ -28,13 +28,68 @@ pub type TxAsMultiValue<M> = MultiValue7<
 pub type PaymentsVec<M> = ManagedVec<M, EsdtTokenPayment<M>>;
 pub type TxBatchSplitInFields<M> = MultiValue2<BatchId, MultiValueEncoded<M, TxAsMultiValue<M>>>;
 
+#[derive(TopEncode, TopDecode, NestedEncode, NestedDecode, TypeAbi, ManagedVecItem, Clone)]
+pub struct Operation<M: ManagedTypeApi> {
+    pub to: ManagedAddress<M>,
+    pub tokens: ManagedVec<M, OperationEsdtPayment<M>>,
+    pub data: OperationData<M>,
+}
+
+impl<M: ManagedTypeApi> Operation<M> {
+    pub fn get_tokens_as_tuple_arr(
+        &self,
+    ) -> MultiValueEncoded<M, MultiValue3<TokenIdentifier<M>, u64, EsdtTokenData<M>>> {
+        let mut tuple_arr = MultiValueEncoded::new();
+
+        for token in &self.tokens {
+            tuple_arr.push(MultiValue3::from((
+                token.token_identifier,
+                token.token_nonce,
+                token.token_data.into(),
+            )));
+        }
+
+        tuple_arr
+    }
+}
+
 #[derive(TopEncode, TopDecode, NestedEncode, NestedDecode, TypeAbi, ManagedVecItem, Clone)]
 pub struct TransferData<M: ManagedTypeApi> {
     pub gas_limit: GasLimit,
     pub function: ManagedBuffer<M>,
     pub args: ManagedVec<M, ManagedBuffer<M>>,
 }
 
+#[derive(TopEncode, TopDecode, NestedEncode, NestedDecode, TypeAbi, ManagedVecItem, Clone)]
+pub struct OperationData<M: ManagedTypeApi> {
+    pub op_nonce: TxId,
+    pub op_sender: ManagedAddress<M>,
+    pub opt_transfer_data: Option<TransferData<M>>,
+}
+
+#[derive(TopEncode, TopDecode, NestedEncode, NestedDecode, TypeAbi, ManagedVecItem, Clone)]
+pub struct OperationTuple<M: ManagedTypeApi> {
+    pub op_hash: ManagedBuffer<M>,
+    pub operation: Operation<M>,
+}
+
+#[derive(TopEncode, TopDecode, NestedEncode, NestedDecode, TypeAbi, ManagedVecItem, Clone)]
+pub struct OperationEsdtPayment<M: ManagedTypeApi> {
+    pub token_identifier: TokenIdentifier<M>,
+    pub token_nonce: u64,
+    pub token_data: StolenFromFrameworkEsdtTokenData<M>,
+}
+
+impl<M: ManagedTypeApi> From<OperationEsdtPayment<M>> for EsdtTokenPayment<M> {
+    fn from(payment: OperationEsdtPayment<M>) -> Self {
+        EsdtTokenPayment {
+            token_identifier: payment.token_identifier,
+            token_nonce: payment.token_nonce,
+            amount: payment.token_data.amount,
+        }
+    }
+}
+
 // Temporary until Clone is implemented for EsdtTokenData
 #[derive(
     TopDecode, TopEncode, NestedDecode, NestedEncode, TypeAbi, Debug, ManagedVecItem, Clone,
@@ -83,6 +138,22 @@ impl<M: ManagedTypeApi> From<EsdtTokenData<M>> for StolenFromFrameworkEsdtTokenD
     }
 }
 
+impl<M: ManagedTypeApi> From<StolenFromFrameworkEsdtTokenData<M>> for EsdtTokenData<M> {
+    fn from(token_data: StolenFromFrameworkEsdtTokenData<M>) -> Self {
+        EsdtTokenData {
+            token_type: token_data.token_type,
+            amount: token_data.amount,
+            frozen: token_data.frozen,
+            hash: token_data.hash,
+            name: token_data.name,
+            attributes: token_data.attributes,
+            creator: token_data.creator,
+            royalties: token_data.royalties,
+            uris: token_data.uris,
+        }
+    }
+}
+
 #[derive(TopEncode, TopDecode, NestedEncode, NestedDecode, TypeAbi, ManagedVecItem, Clone)]
 pub struct Transaction<M: ManagedTypeApi> {
     pub block_nonce: BlockNonce,

esdt-safe/Cargo.toml

@@ -32,6 +32,9 @@ path = "../common/utils"
 [dependencies.fee-market]
 path = "../fee-market"
 
+[dependencies.multisigverifier]
+path = "../multisigverifier"
+
 [dependencies.multiversx-sc]
 version = "=0.48.0"
 

esdt-safe/src/from_sovereign/events.rs

@@ -1,41 +1,11 @@
-use transaction::{BatchId, Transaction, TxId};
-
 multiversx_sc::imports!();
 
 #[multiversx_sc::module]
 pub trait EventsModule {
-    #[event("addRefundTransactionEvent")]
-    fn add_refund_transaction_event(
-        &self,
-        #[indexed] tx_id: TxId,
-        #[indexed] original_tx_id: TxId,
-    );
-
-    #[event("transferPerformedEvent")]
-    fn transfer_performed_event(
-        &self,
-        #[indexed] batch_id: BatchId,
-        #[indexed] tx_id: TxId,
-        tx: Transaction<Self::Api>,
-    );
-
-    #[event("transferFailedInvalidToken")]
-    fn transfer_failed_invalid_token(&self, #[indexed] batch_id: BatchId, #[indexed] tx_id: TxId);
-
-    #[event("transferFailedFrozenDestinationAccount")]
-    fn transfer_failed_frozen_destination_account(
-        &self,
-        #[indexed] batch_id: BatchId,
-        #[indexed] tx_id: TxId,
-    );
-
-    #[event("transferOverMaxAmount")]
-    fn transfer_over_max_amount(&self, #[indexed] batch_id: BatchId, #[indexed] tx_id: TxId);
-
-    #[event("transferFailedExecutionFailed")]
-    fn transfer_failed_execution_failed(
+    #[event("executedBridgeOp")]
+    fn execute_bridge_operation_event(
         &self,
-        #[indexed] batch_id: BatchId,
-        #[indexed] tx_id: TxId,
+        #[indexed] hash_of_hashes: ManagedBuffer,
+        #[indexed] hash_of_bridge_op: ManagedBuffer,
     );
 }

esdt-safe/src/from_sovereign/refund.rs

@@ -1,11 +1,11 @@
-use transaction::{BatchId, PaymentsVec, Transaction, TxNonce};
+use transaction::{BatchId, OperationEsdtPayment, PaymentsVec, Transaction, TxNonce};
 
 multiversx_sc::imports!();
 
 const NFT_AMOUNT: u32 = 1;
 
 pub struct CheckMustRefundArgs<'a, M: ManagedTypeApi> {
-    pub token: &'a EsdtTokenPayment<M>,
+    pub token: &'a OperationEsdtPayment<M>,
     pub roles: EsdtLocalRoleFlags,
     pub dest: &'a ManagedAddress<M>,
     pub batch_id: BatchId,
@@ -26,42 +26,40 @@ pub trait RefundModule:
             &args.token.token_identifier,
             args.token.token_nonce,
         );
-        if token_balance < args.token.amount {
+
+        if token_balance < args.token.token_data.amount {
             if args.token.token_nonce == 0 {
                 if !args.roles.has_role(&EsdtLocalRole::Mint) {
-                    self.transfer_failed_invalid_token(args.batch_id, args.tx_nonce);
-
                     return true;
                 }
             } else if !self.has_nft_roles(args.token, args.roles) {
-                self.transfer_failed_invalid_token(args.batch_id, args.tx_nonce);
-
                 return true;
             }
         }
 
-        if self.is_above_max_amount(&args.token.token_identifier, &args.token.amount) {
-            self.transfer_over_max_amount(args.batch_id, args.tx_nonce);
-
+        if self.is_above_max_amount(&args.token.token_identifier, &args.token.token_data.amount) {
             return true;
         }
 
         if self.is_account_same_shard_frozen(args.sc_shard, args.dest, &args.token.token_identifier)
         {
-            self.transfer_failed_frozen_destination_account(args.batch_id, args.tx_nonce);
-
             return true;
         }
 
         false
     }
 
-    fn has_nft_roles(&self, payment: &EsdtTokenPayment, roles: EsdtLocalRoleFlags) -> bool {
+    fn has_nft_roles(
+        &self,
+        payment: &OperationEsdtPayment<Self::Api>,
+        roles: EsdtLocalRoleFlags,
+    ) -> bool {
         if !roles.has_role(&EsdtLocalRole::NftCreate) {
             return false;
         }
 
-        if payment.amount > NFT_AMOUNT && !roles.has_role(&EsdtLocalRole::NftAddQuantity) {
+        if payment.token_data.amount > NFT_AMOUNT && !roles.has_role(&EsdtLocalRole::NftAddQuantity)
+        {
             return false;
         }
 
@@ -91,7 +89,6 @@ pub trait RefundModule:
         tokens_to_refund: PaymentsVec<Self::Api>,
     ) -> Transaction<Self::Api> {
         let tx_nonce = self.get_and_save_next_tx_id();
-        self.add_refund_transaction_event(tx_nonce, sov_tx.nonce);
 
         // invert from and to
         Transaction {