Primata/405 move get bridge transfer details

protocol-units/bridge/move-modules/sources/atomic_bridge_counterparty.move

@@ -18,7 +18,7 @@ module atomic_bridge::atomic_bridge_counterparty {
         aborted_transfers: SmartTable<vector<u8>, BridgeTransferDetails>,
     }
 
-    struct BridgeTransferDetails has key, store {
+    struct BridgeTransferDetails has key, store, copy {
         initiator: vector<u8>, // eth address
         recipient: address,
         amount: u64,
@@ -72,6 +72,25 @@ module atomic_bridge::atomic_bridge_counterparty {
         move_to(resource, bridge_transfer_store);
         move_to(resource, bridge_config);
     }
+
+    #[view]
+    public fun bridge_transfers(bridge_transfer_id : vector<u8>) : BridgeTransfer acquires BridgeTransferStore, BridgeConfig {
+        let config_address = borrow_global<BridgeConfig>(@atomic_bridge).bridge_module_deployer;
+        let store = borrow_global<BridgeTransferStore>(config_address);
+        if (!aptos_std::smart_table::contains(&store.transfers, bridge_transfer_id)){
+            BridgeTransfer {
+                amount: 0,
+                originator: @atomic_bridge,
+                recipient: vector::empty<u8>(),
+                hash_lock: vector::empty<u8>(),
+                time_lock: 0,
+                state: 0,
+            }
+        } else {
+            let bridge_transfer = aptos_std::smart_table::borrow(&store.transfers, bridge_transfer_id);
+            *bridge_transfer
+        }
+    }
 
     public fun lock_bridge_transfer_assets(
         caller: &signer,
@@ -230,4 +249,46 @@ module atomic_bridge::atomic_bridge_counterparty {
         assert!(transfer_details.hash_lock == hash_lock, 3);
         assert!(transfer_details.initiator == initiator, 4);
     }
+
+    #[test(origin_account = @origin_addr, resource_addr = @resource_addr, aptos_framework = @0x1, creator = @atomic_bridge, source_account = @source_account, moveth = @moveth, admin = @admin, client = @0xdca, master_minter = @master_minter)]
+    fun test_bridge_transfers_view(
+        origin_account: &signer,
+        resource_addr: signer,
+        client: &signer,
+        aptos_framework: signer,
+        master_minter: &signer, 
+        creator: &signer,
+        moveth: &signer,
+        source_account: &signer
+    ) acquires BridgeTransferStore, BridgeConfig {
+        set_up_test(origin_account, &resource_addr);
+
+        timestamp::set_time_has_started_for_testing(&aptos_framework);
+        moveth::init_for_test(moveth);
+        let receiver_address = @0xdada;
+        let initiator = b"0x123"; //In real world this would be an ethereum address
+        let recipient = @0xface; 
+        let asset = moveth::metadata();
+
+        let bridge_transfer_id = b"transfer1";
+        let pre_image = b"secret";
+        let hash_lock = keccak256(pre_image); 
+        let time_lock = 3600;
+        let amount = 100;
+        let result = lock_bridge_transfer_assets(
+            origin_account,
+            initiator,
+            bridge_transfer_id,
+            hash_lock,
+            time_lock,
+            recipient,
+            amount
+        );
+        assert!(result, 1);
+        // Verify that the transfer is stored in pending_transfers
+        let bridge_store = borrow_global<BridgeTransferStore>(signer::address_of(&resource_addr));
+        let transfer_details = bridge_transfers(bridge_transfer_id);
+        assert!(transfer_details.recipient == recipient, 2);
+        assert!(transfer_details.initiator == initiator, 3);
+    }
 }

protocol-units/bridge/move-modules/sources/atomic_bridge_initiator.move

@@ -25,7 +25,7 @@ module atomic_bridge::atomic_bridge_initiator {
     const ETIMELOCK_EXPIRED: u64 = 5;
     const ENOT_EXPIRED: u64 = 6;
 
-    struct BridgeTransfer has key, store, drop {
+    struct BridgeTransfer has key, store, drop, copy {
         amount: u64,
         originator: address,
         recipient: vector<u8>, // eth address
@@ -80,13 +80,32 @@ module atomic_bridge::atomic_bridge_initiator {
         });
     }
 
+    #[view]
+    public fun bridge_transfers(bridge_transfer_id : vector<u8>) : BridgeTransfer acquires BridgeTransferStore, BridgeConfig {
+        let config_address = borrow_global<BridgeConfig>(@atomic_bridge).bridge_module_deployer;
+        let store = borrow_global<BridgeTransferStore>(config_address);
+        if (!aptos_std::smart_table::contains(&store.transfers, bridge_transfer_id)){
+            BridgeTransfer {
+                amount: 0,
+                originator: @atomic_bridge,
+                recipient: vector::empty<u8>(),
+                hash_lock: vector::empty<u8>(),
+                time_lock: 0,
+                state: 0,
+            }
+        } else {
+            let bridge_transfer = aptos_std::smart_table::borrow(&store.transfers, bridge_transfer_id);
+            *bridge_transfer
+        }
+    }
+
     public fun initiate_bridge_transfer(
         initiator: &signer,
         recipient: vector<u8>, // eth address
         hash_lock: vector<u8>,
         time_lock: u64,
         amount: u64
-    ): vector<u8> acquires BridgeTransferStore, BridgeConfig {
+    ) : vector<u8> acquires BridgeTransferStore, BridgeConfig {
         let addr = signer::address_of(initiator);
         let asset = moveth::metadata();
         let config_address = borrow_global<BridgeConfig>(@atomic_bridge).bridge_module_deployer;
@@ -476,4 +495,59 @@ module atomic_bridge::atomic_bridge_initiator {
 
         assert!(transfer.state == COMPLETED, 300);
     }
+
+    #[test(creator = @moveth, aptos_framework = @0x1, sender = @0xdaff, atomic_bridge = @atomic_bridge)]
+    #[expected_failure(abort_code = 7)]
+    public fun test_bridge_transfers_view(
+        sender: &signer,
+        creator: &signer,
+        aptos_framework: &signer,
+        atomic_bridge: &signer
+    ) acquires BridgeTransferStore, BridgeConfig {
+        init_test(sender, creator, aptos_framework, atomic_bridge);
+
+        let recipient = b"recipient_address";
+        let pre_image = b"pre_image_value";
+        let hash_lock = aptos_std::aptos_hash::keccak256(bcs::to_bytes(&pre_image));
+        assert!(aptos_std::aptos_hash::keccak256(bcs::to_bytes(&pre_image)) == hash_lock, 5);
+        let time_lock = 1000;
+        let amount = 1000;
+        let sender_address = signer::address_of(sender);
+        moveth::mint(atomic_bridge, sender_address, amount);
+
+        let bridge_transfer_id = initiate_bridge_transfer(
+            sender,
+            recipient,
+            hash_lock,
+            time_lock,
+            amount
+        );
+
+        aptos_std::debug::print(&bridge_transfer_id);
+        // returns a valid transfer
+        let bridge_transfer = bridge_transfers(bridge_transfer_id);
+
+        assert!(bridge_transfer.state == INITIALIZED, 6);
+        aptos_std::debug::print(&bridge_transfer.state);
+        complete_bridge_transfer(
+            sender,
+            bridge_transfer_id,
+            pre_image,
+            atomic_bridge
+        );
+        aptos_std::debug::print(&bridge_transfer.state);
+
+        // bridge_transfers doesn't find the transfer id because it has been deleted by complete bridge transfer and returns a new transfer with state 3 (non existent)
+        assert!(bridge_transfers(bridge_transfer_id).state == 3, 7);
+        aptos_std::debug::print(&bridge_transfer.state);
+        // refund fails in borrow_mut because bridge_transfer_id is inexistent as well
+        // weridly this errors but the test passes despite us expecting error 7 only, not 1
+        // abort error::invalid_argument(ENOT_FOUND)
+        refund_bridge_transfer(
+            sender,
+            bridge_transfer_id,
+            atomic_bridge
+        );
+        assert!(bridge_transfers(bridge_transfer_id).state == 3, 7);
+    }
 }