lib.rs

#![cfg_attr(not(feature = "std"), no_std, no_main)]

#[ink::contract]
mod multisig_flipper {

    /// Errors that can occur during contract execution.
    #[derive(Debug, PartialEq, Eq)]
    #[ink::scale_derive(Encode, Decode, TypeInfo)]
    pub enum Error {
        /// The caller is not the admin (multisig account).
        NotAdmin,
    }

    pub type Result<T> = core::result::Result<T, Error>;

    /// Emitted when the boolean value is flipped.
    #[ink(event)]
    pub struct Flipped {
        #[ink(topic)]
        new_value: bool,
    }

    /// Emitted when the admin is changed.
    #[ink(event)]
    pub struct AdminChanged {
        #[ink(topic)]
        old_admin: AccountId,
        #[ink(topic)]
        new_admin: AccountId,
    }

    /// A flipper contract controlled by a multisig account via `pallet-multisig`.
    ///
    /// Only the designated admin (expected to be a multisig account) can call `flip()`.
    /// Multisig members coordinate through `Multisig.as_multi` / `approve_as_multi`
    /// extrinsics wrapping a `Contracts.call(flipper, flip_selector)` inner call.
    /// When the multisig threshold is met, pallet-multisig dispatches the call as the
    /// multisig account, satisfying the admin check.
    #[ink(storage)]
    pub struct MultisigFlipper {
        /// The boolean value that gets flipped.
        value: bool,
        /// The account authorized to call restricted messages.
        /// Expected to be a deterministic multisig account address.
        admin: AccountId,
    }

    impl MultisigFlipper {
        /// Creates the contract with a given initial value and admin account.
        ///
        /// The `admin` should be the precomputed deterministic multisig address
        /// derived from the signatories and threshold.
        #[ink(constructor)]
        pub fn new(init_value: bool, admin: AccountId) -> Self {
            Self {
                value: init_value,
                admin,
            }
        }

        /// Creates the contract with `value = false` and the deployer as admin.
        ///
        /// Use this when the multisig account itself deploys the contract
        /// (by wrapping `Contracts.instantiate` in a multisig call).
        #[ink(constructor)]
        pub fn default() -> Self {
            Self {
                value: false,
                admin: Self::env().caller(),
            }
        }

        /// Flips the stored boolean value. Only callable by the admin.
        ///
        /// When used with pallet-multisig, a member initiates via
        /// `Multisig.as_multi(threshold, others, Contracts.call(this, flip()))`.
        /// Other members approve. Once threshold is met, pallet-multisig
        /// dispatches the call as the multisig account.
        #[ink(message)]
        pub fn flip(&mut self) -> Result<()> {
            self.ensure_admin()?;
            self.value = !self.value;
            self.env().emit_event(Flipped {
                new_value: self.value,
            });
            Ok(())
        }

        /// Returns the current boolean value.
        #[ink(message)]
        pub fn get(&self) -> bool {
            self.value
        }

        /// Returns the current admin account.
        #[ink(message)]
        pub fn get_admin(&self) -> AccountId {
            self.admin
        }

        /// Transfers admin rights to a new account. Only callable by the current admin.
        ///
        /// Use this when the multisig composition changes (members added/removed,
        /// threshold changed), since that produces a new multisig address.
        #[ink(message)]
        pub fn set_admin(&mut self, new_admin: AccountId) -> Result<()> {
            self.ensure_admin()?;
            let old_admin = self.admin;
            self.admin = new_admin;
            self.env().emit_event(AdminChanged {
                old_admin,
                new_admin,
            });
            Ok(())
        }

        /// Checks that the caller is the admin.
        fn ensure_admin(&self) -> Result<()> {
            if self.env().caller() != self.admin {
                return Err(Error::NotAdmin);
            }
            Ok(())
        }
    }

    #[cfg(test)]
    mod tests {
        use super::*;

        fn set_caller(caller: AccountId) {
            ink::env::test::set_caller::<ink::env::DefaultEnvironment>(caller);
        }

        fn default_accounts(
        ) -> ink::env::test::DefaultAccounts<ink::env::DefaultEnvironment> {
            ink::env::test::default_accounts::<ink::env::DefaultEnvironment>()
        }

        #[ink::test]
        fn default_works() {
            let accounts = default_accounts();
            set_caller(accounts.alice);
            let contract = MultisigFlipper::default();
            assert_eq!(contract.get(), false);
            assert_eq!(contract.get_admin(), accounts.alice);
        }

        #[ink::test]
        fn new_with_admin() {
            let accounts = default_accounts();
            let contract = MultisigFlipper::new(true, accounts.bob);
            assert_eq!(contract.get(), true);
            assert_eq!(contract.get_admin(), accounts.bob);
        }

        #[ink::test]
        fn admin_can_flip() {
            let accounts = default_accounts();
            set_caller(accounts.alice);
            let mut contract = MultisigFlipper::default();
            assert_eq!(contract.flip(), Ok(()));
            assert_eq!(contract.get(), true);
        }

        #[ink::test]
        fn non_admin_cannot_flip() {
            let accounts = default_accounts();
            set_caller(accounts.alice);
            let mut contract = MultisigFlipper::default();

            set_caller(accounts.bob);
            assert_eq!(contract.flip(), Err(Error::NotAdmin));
            assert_eq!(contract.get(), false);
        }

        #[ink::test]
        fn admin_can_set_admin() {
            let accounts = default_accounts();
            set_caller(accounts.alice);
            let mut contract = MultisigFlipper::default();

            assert_eq!(contract.set_admin(accounts.bob), Ok(()));
            assert_eq!(contract.get_admin(), accounts.bob);
        }

        #[ink::test]
        fn non_admin_cannot_set_admin() {
            let accounts = default_accounts();
            set_caller(accounts.alice);
            let mut contract = MultisigFlipper::default();

            set_caller(accounts.bob);
            assert_eq!(contract.set_admin(accounts.charlie), Err(Error::NotAdmin));
            assert_eq!(contract.get_admin(), accounts.alice);
        }

        #[ink::test]
        fn flip_toggles_correctly() {
            let accounts = default_accounts();
            set_caller(accounts.alice);
            let mut contract = MultisigFlipper::default();

            assert_eq!(contract.get(), false);
            assert_eq!(contract.flip(), Ok(()));
            assert_eq!(contract.get(), true);
            assert_eq!(contract.flip(), Ok(()));
            assert_eq!(contract.get(), false);
        }

        #[ink::test]
        fn new_admin_can_flip() {
            let accounts = default_accounts();
            set_caller(accounts.alice);
            let mut contract = MultisigFlipper::default();

            // Transfer admin to bob
            assert_eq!(contract.set_admin(accounts.bob), Ok(()));

            // Old admin (alice) cannot flip
            assert_eq!(contract.flip(), Err(Error::NotAdmin));

            // New admin (bob) can flip
            set_caller(accounts.bob);
            assert_eq!(contract.flip(), Ok(()));
            assert_eq!(contract.get(), true);
        }
    }

    #[cfg(all(test, feature = "e2e-tests"))]
    mod e2e_tests {
        use super::*;
        use ink_e2e::ContractsBackend;

        type E2EResult<T> = std::result::Result<T, Box<dyn std::error::Error>>;

        #[ink_e2e::test]
        async fn default_works(mut client: ink_e2e::Client<C, E>) -> E2EResult<()> {
            let mut constructor = MultisigFlipperRef::default();
            let contract = client
                .instantiate("multisig_flipper", &ink_e2e::alice(), &mut constructor)
                .submit()
                .await
                .expect("instantiate failed");
            let call_builder = contract.call_builder::<MultisigFlipper>();

            let get = call_builder.get();
            let get_result = client.call(&ink_e2e::alice(), &get).dry_run().await?;
            assert!(matches!(get_result.return_value(), false));

            Ok(())
        }

        #[ink_e2e::test]
        async fn admin_can_flip(mut client: ink_e2e::Client<C, E>) -> E2EResult<()> {
            // Deploy with bob — bob becomes admin via default()
            let mut constructor = MultisigFlipperRef::default();
            let contract = client
                .instantiate("multisig_flipper", &ink_e2e::bob(), &mut constructor)
                .submit()
                .await
                .expect("instantiate failed");
            let mut call_builder = contract.call_builder::<MultisigFlipper>();

            // Bob (admin) flips
            let flip = call_builder.flip();
            let _flip_result = client
                .call(&ink_e2e::bob(), &flip)
                .submit()
                .await
                .expect("flip failed");

            // Verify value flipped
            let get = call_builder.get();
            let get_result = client.call(&ink_e2e::bob(), &get).dry_run().await?;
            assert!(matches!(get_result.return_value(), true));

            Ok(())
        }

        #[ink_e2e::test]
        async fn non_admin_cannot_flip(
            mut client: ink_e2e::Client<C, E>,
        ) -> E2EResult<()> {
            // Deploy with bob — bob becomes admin
            let mut constructor = MultisigFlipperRef::default();
            let contract = client
                .instantiate("multisig_flipper", &ink_e2e::bob(), &mut constructor)
                .submit()
                .await
                .expect("instantiate failed");
            let mut call_builder = contract.call_builder::<MultisigFlipper>();

            // Alice (non-admin) tries to flip — should fail
            let flip = call_builder.flip();
            let flip_result = client
                .call(&ink_e2e::alice(), &flip)
                .dry_run()
                .await;
            assert!(flip_result.is_err() || {
                let res = flip_result.unwrap();
                res.return_value().is_err()
            });

            // Verify value is still false
            let get = call_builder.get();
            let get_result = client.call(&ink_e2e::bob(), &get).dry_run().await?;
            assert!(matches!(get_result.return_value(), false));

            Ok(())
        }
    }
}