create initial structure and implementation

Author: 0xmovses

protocol-units/bridge/Move.toml

@@ -0,0 +1,15 @@
+[package]
+name = "METHBridge"
+version = "1.0.0"
+authors = []
+
+[addresses]
+
+[dev-addresses]
+
+[dependencies.AptosFramework]
+git = "https://github.com/aptos-labs/aptos-core.git"
+rev = "mainnet"
+subdir = "aptos-move/framework/aptos-framework"
+
+[dev-dependencies]

protocol-units/bridge/sources/METHBridge.move

@@ -0,0 +1,115 @@
+module 0x1::M2ETHBridge {
+    use std::signer;
+    use aptos_framework::coin;
+    use aptos_framework::event;
+
+    struct Deposit has drop, store {
+        owner: address,
+        token_id: u128,
+        nonce: u256,
+        amount: u128,
+    }
+
+    struct DepositEvent has drop, store {
+        deposit: Deposit,
+    }
+
+    struct PendingWithdrawalRequest has drop, store {
+        owner: address,
+        token_id: u128,
+        amount: u128,
+    }
+
+    struct PendingWithdrawal has drop, store {
+        request: PendingWithdrawalRequest,
+        nonce: u256,
+    }
+
+    struct PendingWithdrawalEvent has drop, store {
+        pending_withdrawal: PendingWithdrawal,
+    }
+
+    public entry fun deposit(
+        trusted: &signer,
+        deposit: Deposit
+    ) acquires BridgeAccount {
+        let trusted_address = signer::address_of(trusted);
+        assert!(trusted_address == @M2ETHBridge, 1); // Verify trusted signer
+
+        let bridge_account = borrow_global_mut<BridgeAccount>(trusted_address);
+        let coin = coin::withdraw<AptosCoin>(&bridge_account.coin_store, deposit.amount);
+        coin::deposit(deposit.owner, coin);
+
+        event::emit_event(
+            &mut bridge_account.deposit_events,
+            DepositEvent { deposit }
+        );
+    }
+
+    public entry fun withdraw(
+        owner: &signer,
+        request: PendingWithdrawalRequest
+    ) acquires BridgeAccount {
+        let owner_address = signer::address_of(owner);
+        let coin = coin::withdraw<AptosCoin>(&owner_address, request.amount);
+
+        let bridge_account = borrow_global_mut<BridgeAccount>(@M2ETHBridge);
+        coin::deposit(&bridge_account.coin_store, coin);
+
+        let nonce = bridge_account.nonce;
+        bridge_account.nonce = nonce + 1;
+
+        let pending_withdrawal = PendingWithdrawal {
+            request,
+            nonce,
+        };
+
+        event::emit_event(
+            &mut bridge_account.pending_withdrawal_events,
+            PendingWithdrawalEvent { pending_withdrawal }
+        );
+    }
+
+    public entry fun close_withdrawal_request(
+        trusted: &signer,
+        pending_withdrawal: PendingWithdrawal
+    ) acquires BridgeAccount {
+        let trusted_address = signer::address_of(trusted);
+        assert!(trusted_address == @M2ETHBridge, 1); // Verify trusted signer
+
+        let bridge_account = borrow_global_mut<BridgeAccount>(trusted_address);
+        // Implement logic to confirm and close the withdrawal request
+        // Remove the pending withdrawal from bridge_account
+    }
+
+    public entry fun claim_withdrawal_request(
+        owner: &signer,
+        pending_withdrawal: PendingWithdrawal
+    ) acquires BridgeAccount {
+        let owner_address = signer::address_of(owner);
+        assert!(pending_withdrawal.request.owner == owner_address, 1); // Verify owner
+
+        let bridge_account = borrow_global_mut<BridgeAccount>(@M2ETHBridge);
+        // Implement logic to claim unsuccessful withdrawal request and close it
+        // Remove the pending withdrawal from bridge_account and transfer coins back to owner
+    }
+
+    struct BridgeAccount has key {
+        coin_store: coin::CoinStore<AptosCoin>,
+        deposit_events: event::EventHandle<DepositEvent>,
+        pending_withdrawal_events: event::EventHandle<PendingWithdrawalEvent>,
+        nonce: u256,
+    }
+
+    fun init_module(bridge: &signer) {
+        let bridge_address = signer::address_of(bridge);
+        assert!(bridge_address == @M2ETHBridge, 1); // Verify bridge signer
+
+        move_to(bridge, BridgeAccount {
+            coin_store: coin::create_coin_store(bridge),
+            deposit_events: account::new_event_handle<DepositEvent>(bridge),
+            pending_withdrawal_events: account::new_event_handle<PendingWithdrawalEvent>(bridge),
+            nonce: 0,
+        });
+    }
+}