create-dubhe 0.1.13 → 1.2.0-pre.51

package/template/101/initia-template/contracts/counter/build/counter/sources/dependencies/InitiaStdlib/multisig_v2.move

@@ -1,2465 +0,0 @@
-module initia_std::multisig_v2 {
-    use std::error;
-    use std::option::{Self, Option};
-    use std::signer;
-    use std::string::{Self, String};
-    use std::vector;
-    use std::event;
-
-    use initia_std::block::get_block_info;
-    use initia_std::cosmos::{move_execute, move_execute_with_json};
-    use initia_std::object::{Self, ExtendRef};
-    use initia_std::simple_map::{Self, SimpleMap};
-    use initia_std::table::{Self, Table};
-    use initia_std::type_info;
-
-    // errors
-
-    const EINVALID_THRESHOLD: u64 = 1;
-
-    const ENOT_MEMBER: u64 = 2;
-
-    const EINVALID_PROPOSAL_STATUS: u64 = 3;
-
-    const EPROPOSAL_EXPIRED: u64 = 4;
-
-    const ENOT_PASS: u64 = 5;
-
-    const EPROPOSAL_NOT_FOUND: u64 = 6;
-
-    const EINVALID_TIERS_LENGTH: u64 = 7;
-
-    const EINVALID_MEMBERS_LENGTH: u64 = 8;
-
-    const EINVALID_MEMBER_TIERS: u64 = 9;
-
-    const EINVALID_EXPIRY_TIMESTAMP: u64 = 10;
-
-    const EMULTISIG_NAME_TOO_LONG: u64 = 11;
-
-    const EINVALID_PROPOSAL_MESSAGE_LENGTH: u64 = 12;
-
-    // constants
-
-    const STATUS: vector<vector<u8>> = vector[b"voting", b"executed", b"expired"];
-
-    const MAX_LIMIT: u8 = 30;
-
-    const MAX_MULTISIG_NAME_LENGTH: u64 = 64;
-
-    // structs
-
-    struct Tier has copy, drop, store {
-        name: String,
-        weight: u64
-    }
-
-    struct Member has copy, drop, store {
-        address: address,
-        tier: Option<Tier>
-    }
-
-    struct MultisigWallet has key {
-        extend_ref: ExtendRef,
-        name: String,
-        weighted: bool, // if true -> tiers should be present
-        tiers: Option<vector<Tier>>,
-        members: vector<Member>, // members of multisig account
-        threshold: u64, // require weight to pass
-        proposals: Table<u64, Proposal>
-    }
-
-    struct ExecuteMessage has copy, drop, store {
-        module_address: address,
-        module_name: String,
-        function_name: String,
-        type_args: vector<String>,
-        args: vector<vector<u8>>,
-        json_args: vector<String>
-    }
-
-    struct Proposal has store {
-        proposer: Member,
-        proposed_timestamp: u64,
-        proposed_height: u64,
-        expiry_timestamp: Option<u64>,
-        votes: SimpleMap<Member, bool>,
-        threshold: u64,
-        total_weight: u64,
-        status: u8,
-        is_json: bool,
-        execute_messages: vector<ExecuteMessage>
-    }
-
-    // events
-
-    #[event]
-    struct CreateMultisigAccountEvent has drop, store {
-        multisig_addr: address,
-        name: String,
-        weighted: bool,
-        members: vector<Member>,
-        threshold: u64
-    }
-
-    #[event]
-    struct CreateProposalEvent has drop, store {
-        multisig_addr: address,
-        proposal_id: u64,
-        proposer: Member,
-        execute_messages: vector<ExecuteMessage>
-    }
-
-    #[event]
-    struct VoteProposalEvent has drop, store {
-        multisig_addr: address,
-        proposal_id: u64,
-        voter: Member,
-        vote_yes: bool
-    }
-
-    #[event]
-    struct ExecuteProposalEvent has drop, store {
-        multisig_addr: address,
-        proposal_id: u64,
-        executor: Member
-    }
-
-    #[event]
-    struct UpdateConfigEvent has drop, store {
-        multisig_addr: address,
-        members: vector<Member>,
-        tiers: Option<vector<Tier>>,
-        threshold: u64
-    }
-
-    // view function response struct
-
-    struct ProposalResponse has drop {
-        multisig_addr: address,
-        proposal_id: u64,
-        votes: SimpleMap<Member, bool>,
-        proposer: Member,
-        proposed_height: u64,
-        proposed_timestamp: u64,
-        expiry_timestamp: Option<u64>,
-        threshold: u64,
-        total_weight: u64,
-        yes_vote_score: u64,
-        status: String,
-        is_json: bool,
-        execute_messages: vector<ExecuteMessage>
-    }
-
-    struct MultisigResponse has drop {
-        multisig_addr: address,
-        name: String,
-        members: vector<Member>,
-        threshold: u64,
-        tiers: Option<vector<Tier>>
-    }
-
-    // view functions
-
-    #[view]
-    public fun is_exist(creator_addr: address, name: String): bool {
-        let seed = create_multisig_seed(&name);
-        let multisig_addr = object::create_object_address(&creator_addr, seed);
-        object::object_exists<MultisigWallet>(multisig_addr)
-    }
-
-    #[view]
-    public fun get_multisig(multisig_addr: address): MultisigResponse acquires MultisigWallet {
-        let multisig_wallet = borrow_global<MultisigWallet>(multisig_addr);
-
-        MultisigResponse {
-            multisig_addr,
-            name: multisig_wallet.name,
-            tiers: multisig_wallet.tiers,
-            members: multisig_wallet.members,
-            threshold: multisig_wallet.threshold
-        }
-    }
-
-    #[view]
-    public fun get_proposal(
-        multisig_addr: address, proposal_id: u64
-    ): ProposalResponse acquires MultisigWallet {
-        let multisig_wallet = borrow_global<MultisigWallet>(multisig_addr);
-        let proposal = table::borrow(&multisig_wallet.proposals, proposal_id);
-        proposal_to_proposal_response(
-            multisig_wallet,
-            multisig_addr,
-            proposal_id,
-            proposal
-        )
-    }
-
-    #[view]
-    public fun get_proposals(
-        multisig_addr: address, start_after: Option<u64>, limit: u8
-    ): vector<ProposalResponse> acquires MultisigWallet {
-        if (limit > MAX_LIMIT) {
-            limit = MAX_LIMIT
-        };
-        let res: vector<ProposalResponse> = vector[];
-        let multisig_wallet = borrow_global<MultisigWallet>(multisig_addr);
-        let iter = table::iter(
-            &multisig_wallet.proposals,
-            option::none(),
-            start_after,
-            2
-        );
-
-        while (vector::length(&res) < (limit as u64)
-            && table::prepare<u64, Proposal>(iter)) {
-            let (proposal_id, proposal) = table::next<u64, Proposal>(iter);
-            vector::push_back(
-                &mut res,
-                proposal_to_proposal_response(
-                    multisig_wallet,
-                    multisig_addr,
-                    proposal_id,
-                    proposal
-                )
-            );
-        };
-
-        res
-    }
-
-    // entry functions
-
-    /// Create new non weighted multisig account
-    public entry fun create_non_weighted_multisig_account(
-        account: &signer,
-        name: String, // name for make deterministic multisig address (account_addr + name)
-        members: vector<address>,
-        threshold: u64
-    ) {
-        assert_member(&members, &signer::address_of(account));
-        assert!(
-            vector::length(&members) >= threshold,
-            error::invalid_argument(EINVALID_THRESHOLD)
-        );
-        assert!(
-            threshold > 0,
-            error::invalid_argument(EINVALID_THRESHOLD)
-        );
-
-        let constructor_ref =
-            object::create_named_object(account, create_multisig_seed(&name));
-        let extend_ref = object::generate_extend_ref(&constructor_ref);
-        let multisig_signer = object::generate_signer(&constructor_ref);
-        let multisig_addr = signer::address_of(&multisig_signer);
-
-        assert_uniqueness(members);
-
-        let members = vector::map(
-            members,
-            |member| Member { address: member, tier: option::none() }
-        );
-
-        move_to(
-            &multisig_signer,
-            MultisigWallet {
-                extend_ref,
-                name,
-                members,
-                weighted: false,
-                tiers: option::none(),
-                threshold,
-                proposals: table::new()
-            }
-        );
-
-        event::emit<CreateMultisigAccountEvent>(
-            CreateMultisigAccountEvent {
-                multisig_addr,
-                name,
-                weighted: false,
-                members,
-                threshold
-            }
-        )
-    }
-
-    /// Create new weighted multisig account
-    public entry fun create_weighted_multisig_account(
-        account: &signer,
-        name: String, // name for make deterministic multisig address (account_addr + name)
-        tiers: vector<String>,
-        tier_weights: vector<u64>,
-        members: vector<address>,
-        member_tiers: vector<String>,
-        threshold: u64
-    ) {
-        assert_member(&members, &signer::address_of(account));
-        assert_uniqueness(members);
-        assert_tier_config(tiers, tier_weights, &members, member_tiers);
-        assert_uniqueness(tiers);
-
-        // check threshold computed from each member weights
-        let total_weight = vector::fold(
-            member_tiers,
-            0u64,
-            |acc, tier| {
-                let (_, index) = vector::index_of(&tiers, &tier);
-                acc + *vector::borrow(&tier_weights, index)
-            }
-        );
-        assert!(
-            total_weight >= threshold,
-            error::invalid_argument(EINVALID_THRESHOLD)
-        );
-        assert!(
-            threshold > 0,
-            error::invalid_argument(EINVALID_THRESHOLD)
-        );
-
-        let constructor_ref =
-            object::create_named_object(account, create_multisig_seed(&name));
-        let extend_ref = object::generate_extend_ref(&constructor_ref);
-        let multisig_signer = object::generate_signer(&constructor_ref);
-        let multisig_addr = signer::address_of(&multisig_signer);
-
-        let tiers = vector::map(
-            tiers,
-            |tier| {
-                let (_, index) = vector::index_of(&tiers, &tier);
-                Tier { name: tier, weight: *vector::borrow(&tier_weights, index) }
-            }
-        );
-
-        let members = construct_members_with_tiers(members, member_tiers, tiers);
-
-        move_to(
-            &multisig_signer,
-            MultisigWallet {
-                extend_ref,
-                name,
-                members,
-                weighted: true,
-                tiers: option::some(tiers),
-                threshold,
-                proposals: table::new()
-            }
-        );
-
-        event::emit<CreateMultisigAccountEvent>(
-            CreateMultisigAccountEvent {
-                multisig_addr,
-                weighted: true,
-                name,
-                members,
-                threshold
-            }
-        )
-    }
-
-    fun total_weight(members: &vector<Member>): u64 {
-        vector::fold(
-            *members,
-            0u64,
-            |acc, member| {
-                let m: Member = member;
-                acc
-                    + if (option::is_some(&m.tier)) {
-                        let tier = *option::borrow(&m.tier);
-                        tier.weight
-                    } else { 1u64 }
-            }
-        )
-    }
-
-    /// Create new proposal
-    public entry fun create_proposal(
-        account: &signer,
-        multisig_addr: address,
-        module_address_list: vector<address>,
-        module_name_list: vector<String>,
-        function_name_list: vector<String>,
-        type_args_list: vector<vector<String>>,
-        args_list: vector<vector<vector<u8>>>,
-        expiry_duration: Option<u64>
-    ) acquires MultisigWallet {
-        assert!(
-            vector::length(&module_address_list) == vector::length(&module_name_list)
-                && vector::length(&module_name_list)
-                    == vector::length(&function_name_list)
-                && vector::length(&function_name_list)
-                    == vector::length(&type_args_list)
-                && vector::length(&type_args_list) == vector::length(&args_list),
-            error::invalid_argument(EINVALID_PROPOSAL_MESSAGE_LENGTH)
-        );
-
-        let index = 0;
-        let execute_messages = vector::map<address, ExecuteMessage>(
-            module_address_list,
-            |module_address| {
-                let module_name = *vector::borrow(&module_name_list, index);
-                let function_name = *vector::borrow(&function_name_list, index);
-                let type_args = *vector::borrow(&type_args_list, index);
-                let args = *vector::borrow(&args_list, index);
-                index = index + 1;
-
-                ExecuteMessage {
-                    module_address,
-                    module_name,
-                    function_name,
-                    type_args,
-                    args,
-                    json_args: vector[]
-                }
-            }
-        );
-
-        create_proposal_internal(
-            account,
-            multisig_addr,
-            false,
-            execute_messages,
-            expiry_duration
-        )
-    }
-
-    /// Create new proposal
-    public entry fun create_proposal_with_json(
-        account: &signer,
-        multisig_addr: address,
-        module_address_list: vector<address>,
-        module_name_list: vector<String>,
-        function_name_list: vector<String>,
-        type_args_list: vector<vector<String>>,
-        args_list: vector<vector<String>>,
-        expiry_duration: Option<u64>
-    ) acquires MultisigWallet {
-        assert!(
-            vector::length(&module_address_list) == vector::length(&module_name_list)
-                && vector::length(&module_name_list)
-                    == vector::length(&function_name_list)
-                && vector::length(&function_name_list)
-                    == vector::length(&type_args_list)
-                && vector::length(&type_args_list) == vector::length(&args_list),
-            error::invalid_argument(EINVALID_PROPOSAL_MESSAGE_LENGTH)
-        );
-
-        let index = 0;
-        let execute_messages = vector::map<address, ExecuteMessage>(
-            module_address_list,
-            |module_address| {
-                let module_name = *vector::borrow(&module_name_list, index);
-                let function_name = *vector::borrow(&function_name_list, index);
-                let type_args = *vector::borrow(&type_args_list, index);
-                let json_args = *vector::borrow(&args_list, index);
-                index = index + 1;
-
-                ExecuteMessage {
-                    module_address,
-                    module_name,
-                    function_name,
-                    type_args,
-                    args: vector[],
-                    json_args
-                }
-            }
-        );
-
-        create_proposal_internal(
-            account,
-            multisig_addr,
-            true,
-            execute_messages,
-            expiry_duration
-        )
-    }
-
-    /// Vote proposal
-    public entry fun vote_proposal(
-        account: &signer,
-        multisig_addr: address,
-        proposal_id: u64,
-        vote_yes: bool
-    ) acquires MultisigWallet {
-        let voter_address = signer::address_of(account);
-        let multisig_wallet = borrow_global_mut<MultisigWallet>(multisig_addr);
-        assert_multisig_member(&multisig_wallet.members, &voter_address);
-
-        assert!(
-            table::contains(&multisig_wallet.proposals, proposal_id),
-            error::invalid_argument(EPROPOSAL_NOT_FOUND)
-        );
-        let proposal = table::borrow_mut(&mut multisig_wallet.proposals, proposal_id);
-
-        assert_proposal(proposal);
-
-        let voter = get_member_by_address(multisig_wallet.members, voter_address);
-        vote(&mut proposal.votes, voter, vote_yes);
-
-        event::emit<VoteProposalEvent>(
-            VoteProposalEvent { multisig_addr, proposal_id, voter, vote_yes }
-        )
-    }
-
-    /// Execute proposal
-    public entry fun execute_proposal(
-        account: &signer, multisig_addr: address, proposal_id: u64
-    ) acquires MultisigWallet {
-        let executor_address = signer::address_of(account);
-        let multisig_wallet = borrow_global_mut<MultisigWallet>(multisig_addr);
-        let executor = get_member_by_address(multisig_wallet.members, executor_address);
-        assert_multisig_member(&multisig_wallet.members, &executor_address);
-
-        assert!(
-            table::contains(&multisig_wallet.proposals, proposal_id),
-            error::invalid_argument(EPROPOSAL_NOT_FOUND)
-        );
-        let proposal = table::borrow_mut(&mut multisig_wallet.proposals, proposal_id);
-
-        assert_proposal(proposal);
-
-        // check passed
-        assert!(
-            yes_vote_score(&proposal.votes, &multisig_wallet.members)
-                >= multisig_wallet.threshold,
-            error::invalid_state(ENOT_PASS)
-        );
-
-        let multisig_signer =
-            &object::generate_signer_for_extending(&multisig_wallet.extend_ref);
-
-        proposal.status = 1; // change the status first in case of updating config
-
-        if (!proposal.is_json) {
-            vector::for_each(
-                proposal.execute_messages,
-                |execute_message| {
-                    let m: ExecuteMessage = execute_message;
-                    move_execute(
-                        multisig_signer,
-                        m.module_address,
-                        m.module_name,
-                        m.function_name,
-                        m.type_args,
-                        m.args
-                    )
-                }
-            )
-        } else {
-            vector::for_each(
-                proposal.execute_messages,
-                |execute_message| {
-                    let m: ExecuteMessage = execute_message;
-                    move_execute_with_json(
-                        multisig_signer,
-                        m.module_address,
-                        m.module_name,
-                        m.function_name,
-                        m.type_args,
-                        m.json_args
-                    )
-                }
-            )
-        };
-
-        event::emit<ExecuteProposalEvent>(
-            ExecuteProposalEvent { multisig_addr, proposal_id, executor }
-        )
-    }
-
-    /// Update config. Only execute by multisig wallet itself
-    public entry fun update_config(
-        account: &signer,
-        new_members: vector<address>,
-        new_tiers: Option<vector<String>>,
-        new_tier_weights: Option<vector<u64>>,
-        new_member_tiers: Option<vector<String>>,
-        new_threshold: u64
-    ) acquires MultisigWallet {
-        let multisig_addr = signer::address_of(account);
-        let multisig_wallet = borrow_global_mut<MultisigWallet>(multisig_addr);
-
-        assert_uniqueness(new_members);
-
-        let removed_members = vector::filter(
-            multisig_wallet.members,
-            |member| {
-                let m: &Member = member;
-                !vector::contains(&new_members, &m.address)
-            }
-        );
-
-        if (multisig_wallet.weighted) {
-            let new_tiers = *option::borrow(&new_tiers);
-            let new_tier_weights = *option::borrow(&new_tier_weights);
-            let new_member_tiers = *option::borrow(&new_member_tiers);
-
-            assert_tier_config(
-                new_tiers,
-                new_tier_weights,
-                &new_members,
-                new_member_tiers
-            );
-            assert_uniqueness(new_tiers);
-
-            // check threshold computed from each member weights
-            let total_weight = vector::fold(
-                new_member_tiers,
-                0u64,
-                |acc, tier| {
-                    let (_, index) = vector::index_of(&new_tiers, &tier);
-                    acc + *vector::borrow(&new_tier_weights, index)
-                }
-            );
-
-            assert!(
-                total_weight >= new_threshold,
-                error::invalid_argument(EINVALID_THRESHOLD)
-            );
-            assert!(
-                new_threshold > 0,
-                error::invalid_argument(EINVALID_THRESHOLD)
-            );
-
-            let tiers = vector::map(
-                new_tiers,
-                |tier| {
-                    let (_, index) = vector::index_of(&new_tiers, &tier);
-                    Tier { name: tier, weight: *vector::borrow(&new_tier_weights, index) }
-                }
-            );
-
-            multisig_wallet.threshold = new_threshold;
-            multisig_wallet.tiers = option::some(tiers);
-            multisig_wallet.members = construct_members_with_tiers(
-                new_members, new_member_tiers, tiers
-            );
-        } else {
-            assert!(
-                vector::length(&new_members) >= new_threshold,
-                error::invalid_argument(EINVALID_THRESHOLD)
-            );
-
-            multisig_wallet.threshold = new_threshold;
-            multisig_wallet.members = vector::map(
-                new_members,
-                |member| Member { address: member, tier: option::none() }
-            );
-        };
-
-        // remove votes of the removed members from active proposals
-        let iter =
-            table::iter_mut(
-                &mut multisig_wallet.proposals,
-                option::none(),
-                option::none(),
-                2
-            );
-        while (table::prepare<u64, Proposal>(iter)) {
-            let (_, proposal) = table::next_mut<u64, Proposal>(iter);
-            // only cares about active proposals
-            if (proposal.status != 0 || is_proposal_expired(proposal)) {
-                continue
-            };
-
-            proposal.threshold = new_threshold;
-            proposal.total_weight = total_weight(&multisig_wallet.members);
-
-            // remove removed_members votes
-            vector::for_each(
-                removed_members,
-                |member| {
-                    let m: Member = member;
-                    if (simple_map::contains_key(&proposal.votes, &m)) {
-                        simple_map::remove(&mut proposal.votes, &m);
-                    }
-                }
-            );
-        };
-
-        event::emit<UpdateConfigEvent>(
-            UpdateConfigEvent {
-                multisig_addr,
-                members: multisig_wallet.members,
-                tiers: multisig_wallet.tiers,
-                threshold: multisig_wallet.threshold
-            }
-        )
-    }
-
-    // public functions
-
-    public fun create_multisig_seed(name: &String): vector<u8> {
-        assert!(
-            string::length(name) <= MAX_MULTISIG_NAME_LENGTH,
-            error::out_of_range(EMULTISIG_NAME_TOO_LONG)
-        );
-
-        let type_name = type_info::type_name<MultisigWallet>();
-        let seed = *string::bytes(&type_name);
-        vector::append(&mut seed, *string::bytes(name));
-        seed
-    }
-
-    // private functions
-
-    fun construct_members_with_tiers(
-        members: vector<address>, member_tiers: vector<String>, tiers: vector<Tier>
-    ): vector<Member> {
-        let index = 0;
-        vector::map(
-            members,
-            |member| {
-                let tier_name = *vector::borrow(&member_tiers, index);
-                index = index + 1;
-
-                // find tier with tier_name in tiers
-                let (found, tier_index) = vector::find(
-                    &tiers,
-                    |t| {
-                        let tt: &Tier = t;
-                        tt.name == tier_name
-                    }
-                );
-
-                assert!(found, error::invalid_argument(EINVALID_MEMBER_TIERS));
-
-                let tier = *vector::borrow(&tiers, tier_index);
-
-                Member { address: member, tier: option::some(tier) }
-            }
-        )
-    }
-
-    fun get_member_by_address(members: vector<Member>, address: address): Member {
-        let (found, index) = vector::find(
-            &members,
-            |member| {
-                let m: &Member = member;
-                m.address == address
-            }
-        );
-
-        assert!(found, error::permission_denied(ENOT_MEMBER));
-
-        *vector::borrow(&members, index)
-    }
-
-    fun create_proposal_internal(
-        account: &signer,
-        multisig_addr: address,
-        is_json: bool,
-        execute_messages: vector<ExecuteMessage>,
-        expiry_duration: Option<u64>
-    ) acquires MultisigWallet {
-        let addr = signer::address_of(account);
-        let multisig_wallet = borrow_global_mut<MultisigWallet>(multisig_addr);
-        assert_multisig_member(&multisig_wallet.members, &addr);
-
-        let (height, timestamp) = get_block_info();
-
-        let expiry_timestamp =
-            if (option::is_some(&expiry_duration)) {
-                let time_until_expired = *option::borrow(&expiry_duration);
-                option::some(timestamp + time_until_expired)
-            } else {
-                option::none()
-            };
-
-        // proposer votes yes on proposal creation
-        let votes = simple_map::create<Member, bool>();
-        let proposer = get_member_by_address(multisig_wallet.members, addr);
-        simple_map::add(&mut votes, proposer, true);
-
-        let proposal = Proposal {
-            proposer,
-            proposed_height: height,
-            proposed_timestamp: timestamp,
-            expiry_timestamp,
-            threshold: multisig_wallet.threshold,
-            total_weight: total_weight(&multisig_wallet.members),
-            votes,
-            status: 0, // in voting period
-            is_json,
-            execute_messages
-        };
-
-        let proposal_id = table::length(&multisig_wallet.proposals) + 1;
-        table::add(
-            &mut multisig_wallet.proposals,
-            proposal_id,
-            proposal
-        );
-
-        event::emit<CreateProposalEvent>(
-            CreateProposalEvent { multisig_addr, proposal_id, proposer, execute_messages }
-        )
-    }
-
-    fun is_proposal_expired(proposal: &Proposal): bool {
-        let (_, timestamp) = get_block_info();
-
-        if (option::is_none(&proposal.expiry_timestamp)) {
-            return false
-        };
-
-        let expiry = *option::borrow(&proposal.expiry_timestamp);
-
-        return timestamp >= expiry
-    }
-
-    fun vote(
-        votes: &mut SimpleMap<Member, bool>,
-        voter: Member,
-        vote_yes: bool
-    ) {
-        if (simple_map::contains_key(votes, &voter)) {
-            let vote = simple_map::borrow_mut(votes, &voter);
-            *vote = vote_yes;
-        } else {
-            simple_map::add(votes, voter, vote_yes);
-        };
-    }
-
-    fun yes_vote_score(
-        votes: &SimpleMap<Member, bool>, members: &vector<Member>
-    ): u64 {
-        vector::fold(
-            *members,
-            0u64,
-            |acc, member| {
-                let m: Member = member;
-                let weight =
-                    if (option::is_some(&m.tier)) {
-                        let tier = *option::borrow(&m.tier);
-                        tier.weight
-                    } else { 1u64 };
-                if (simple_map::contains_key(votes, &m)
-                    && *simple_map::borrow(votes, &m)) {
-                    acc + weight
-                } else { acc }
-            }
-        )
-    }
-
-    fun proposal_to_proposal_response(
-        multisig_wallet: &MultisigWallet,
-        multisig_addr: address,
-        proposal_id: u64,
-        proposal: &Proposal
-    ): ProposalResponse {
-        let status_index = proposal.status;
-        let is_expired = is_proposal_expired(proposal);
-        let yes_vote_score = yes_vote_score(&proposal.votes, &multisig_wallet.members);
-        if (status_index == 0 && is_expired) {
-            status_index = 2
-        };
-
-        ProposalResponse {
-            multisig_addr,
-            proposal_id,
-            proposer: proposal.proposer,
-            proposed_height: proposal.proposed_height,
-            proposed_timestamp: proposal.proposed_timestamp,
-            expiry_timestamp: proposal.expiry_timestamp,
-            votes: proposal.votes,
-            threshold: proposal.threshold,
-            total_weight: proposal.total_weight,
-            yes_vote_score,
-            status: string::utf8(*vector::borrow(&STATUS, (status_index as u64))),
-            is_json: proposal.is_json,
-            execute_messages: proposal.execute_messages
-        }
-    }
-
-    inline fun assert_uniqueness<T: store>(vec: vector<T>) {
-        let m = simple_map::create<T, bool>();
-        vector::for_each(vec, |elem| simple_map::add(&mut m, elem, true))
-    }
-
-    inline fun assert_member(members: &vector<address>, member: &address) {
-        assert!(
-            vector::contains(members, member),
-            error::permission_denied(ENOT_MEMBER)
-        )
-    }
-
-    inline fun assert_multisig_member(
-        multisig_members: &vector<Member>, member: &address
-    ) {
-        let member_addresses = vector::map_ref(
-            multisig_members,
-            |multisig_member| {
-                let m: &Member = multisig_member;
-                m.address
-            }
-        );
-
-        assert_member(&member_addresses, member)
-    }
-
-    inline fun assert_proposal(proposal: &Proposal) {
-        assert!(
-            proposal.status == 0,
-            error::invalid_state(EINVALID_PROPOSAL_STATUS)
-        );
-        assert!(
-            !is_proposal_expired(proposal),
-            error::invalid_state(EPROPOSAL_EXPIRED)
-        );
-    }
-
-    inline fun assert_tier_config(
-        tiers: vector<String>,
-        tier_weights: vector<u64>,
-        members: &vector<address>,
-        member_tiers: vector<String>
-    ) {
-        assert!(
-            vector::length(&tiers) == vector::length(&tier_weights),
-            error::invalid_argument(EINVALID_TIERS_LENGTH)
-        );
-
-        assert!(
-            vector::length(members) == vector::length(&member_tiers),
-            error::invalid_argument(EINVALID_MEMBERS_LENGTH)
-        );
-
-        vector::for_each(
-            member_tiers,
-            |tier| assert!(
-                vector::contains(&tiers, &tier),
-                error::invalid_argument(EINVALID_MEMBER_TIERS)
-            )
-        );
-    }
-
-    #[test_only]
-    use initia_std::address;
-    #[test_only]
-    use initia_std::block::set_block_info;
-
-    #[test_only]
-    fun get_multisig_address(creator: &address, name: &String): address {
-        let seed = address::to_string(@initia_std);
-        string::append(&mut seed, string::utf8(b"::multisig_v2::MultisigWallet"));
-        string::append(&mut seed, *name);
-
-        object::create_object_address(creator, *string::bytes(&seed))
-    }
-
-    // create test_only function for create votes map
-    #[test_only]
-    fun create_votes_map(members: vector<Member>, votes: vector<bool>):
-        SimpleMap<Member, bool> {
-        let votes_map = simple_map::create<Member, bool>();
-        let index = 0;
-        vector::for_each(
-            members,
-            |member| {
-                let vote = *vector::borrow(&votes, index);
-                index = index + 1;
-
-                simple_map::add(&mut votes_map, member, vote)
-            }
-        );
-
-        votes_map
-    }
-
-    // view functions tests
-
-    #[test(account1 = @0x101, account2 = @0x102, account3 = @0x103)]
-    fun is_exist_test(
-        account1: signer, account2: signer, account3: signer
-    ) {
-        let addr1 = signer::address_of(&account1);
-        let addr2 = signer::address_of(&account2);
-        let addr3 = signer::address_of(&account3);
-
-        let name = string::utf8(b"multisig wallet");
-
-        assert!(!is_exist(addr1, name), 1);
-
-        create_non_weighted_multisig_account(
-            &account1, name, vector[addr1, addr2, addr3], 2
-        );
-
-        assert!(is_exist(addr1, name), 1)
-    }
-
-    #[test(
-        account1 = @0x101, account2 = @0x102, account3 = @0x103, account4 = @0x104
-    )]
-    #[expected_failure(abort_code = 0x50002, location = Self)]
-    fun create_non_weighted_wallet_by_other(
-        account1: signer,
-        account2: signer,
-        account3: signer,
-        account4: signer
-    ) {
-        // create multisig wallet
-        let addr1 = signer::address_of(&account1);
-        let addr2 = signer::address_of(&account2);
-        let addr3 = signer::address_of(&account3);
-
-        create_non_weighted_multisig_account(
-            &account4,
-            string::utf8(b"multisig wallet"),
-            vector[addr1, addr2, addr3],
-            2
-        );
-    }
-
-    // test multisig wallet name too long
-    #[test(account1 = @0x101, account2 = @0x102, account3 = @0x103)]
-    #[expected_failure(abort_code = 0x2000b, location = Self)]
-    fun wallet_name_too_long(
-        account1: signer, account2: signer, account3: signer
-    ) {
-        // create multisig wallet
-        let addr1 = signer::address_of(&account1);
-        let addr2 = signer::address_of(&account2);
-        let addr3 = signer::address_of(&account3);
-
-        create_non_weighted_multisig_account(
-            &account1,
-            string::utf8(
-                b"multimultimultimultimultimultimultimultimultimultimultimultimulti"
-            ), // 64 letters
-            vector[addr1, addr2, addr3],
-            2
-        );
-    }
-
-    #[test(account1 = @0x101, account2 = @0x102, account3 = @0x103)]
-    #[expected_failure(abort_code = 0x10001, location = Self)]
-    fun non_weighted_invalid_threshold(
-        account1: signer, account2: signer, account3: signer
-    ) {
-        // create multisig wallet
-        let addr1 = signer::address_of(&account1);
-        let addr2 = signer::address_of(&account2);
-        let addr3 = signer::address_of(&account3);
-
-        create_non_weighted_multisig_account(
-            &account1,
-            string::utf8(b"multisig wallet"),
-            vector[addr1, addr2, addr3],
-            4
-        );
-    }
-
-    #[test(account1 = @0x101, account2 = @0x102, account3 = @0x103)]
-    #[expected_failure(abort_code = 0x10001, location = simple_map)]
-    fun non_weighted_duplicate_members(
-        account1: signer, account2: signer, account3: signer
-    ) {
-        // create multisig wallet
-        let addr1 = signer::address_of(&account1);
-        let addr2 = signer::address_of(&account2);
-        let addr3 = signer::address_of(&account3);
-
-        create_non_weighted_multisig_account(
-            &account1,
-            string::utf8(b"multisig wallet"),
-            vector[addr1, addr1, addr2, addr3],
-            3
-        );
-    }
-
-    // test create weight multisig wallet successfully, check keys in object
-    #[test(account1 = @0x101, account2 = @0x102, account3 = @0x103)]
-    fun create_non_weighted_wallet_success(
-        account1: signer, account2: signer, account3: signer
-    ) acquires MultisigWallet {
-        // create multisig wallet
-        let addr1 = signer::address_of(&account1);
-        let addr2 = signer::address_of(&account2);
-        let addr3 = signer::address_of(&account3);
-
-        create_non_weighted_multisig_account(
-            &account1,
-            string::utf8(b"multisig wallet"),
-            vector[addr1, addr2, addr3],
-            3
-        );
-
-        let multisig_addr = get_multisig_address(
-            &addr1, &string::utf8(b"multisig wallet")
-        );
-        let multisig_wallet = borrow_global<MultisigWallet>(multisig_addr);
-        assert!(
-            vector::length(&multisig_wallet.members) == 3,
-            error::invalid_state(EINVALID_MEMBERS_LENGTH)
-        );
-
-        // assert each member tier is correct
-        vector::for_each_ref(
-            &multisig_wallet.members,
-            |member| {
-                let m: &Member = member;
-                assert!(option::is_none(&m.tier), 1)
-            }
-        );
-
-        assert!(
-            multisig_wallet.threshold == 3,
-            error::invalid_state(EINVALID_THRESHOLD)
-        );
-
-        assert!(
-            !multisig_wallet.weighted,
-            error::invalid_state(1)
-        );
-    }
-
-    #[test(
-        account1 = @0x101, account2 = @0x102, account3 = @0x103, account4 = @0x104
-    )]
-    #[expected_failure(abort_code = 0x50002, location = Self)]
-    fun create_weighted_wallet_by_other(
-        account1: signer,
-        account2: signer,
-        account3: signer,
-        account4: signer
-    ) {
-        // create multisig wallet
-        let addr1 = signer::address_of(&account1);
-        let addr2 = signer::address_of(&account2);
-        let addr3 = signer::address_of(&account3);
-
-        create_weighted_multisig_account(
-            &account4,
-            string::utf8(b"multisig wallet"),
-            vector[string::utf8(b"admin"), string::utf8(b"member")],
-            vector[2, 1],
-            vector[addr1, addr2, addr3],
-            vector[
-                string::utf8(b"admin"),
-                string::utf8(b"member"),
-                string::utf8(b"member")
-            ],
-            2
-        );
-    }
-
-    #[test(
-        account1 = @0x101, account2 = @0x102, account3 = @0x103, account4 = @0x104
-    )]
-    #[expected_failure(abort_code = 0x10007, location = Self)]
-    fun weighted_invalid_tiers_length(
-        account1: signer, account2: signer, account3: signer
-    ) {
-        // create multisig wallet
-        let addr1 = signer::address_of(&account1);
-        let addr2 = signer::address_of(&account2);
-        let addr3 = signer::address_of(&account3);
-
-        create_weighted_multisig_account(
-            &account1,
-            string::utf8(b"multisig wallet"),
-            vector[string::utf8(b"admin"), string::utf8(b"member")],
-            vector[2],
-            vector[addr1, addr2, addr3],
-            vector[
-                string::utf8(b"admin"),
-                string::utf8(b"member"),
-                string::utf8(b"member")
-            ],
-            2
-        );
-    }
-
-    #[test(
-        account1 = @0x101, account2 = @0x102, account3 = @0x103, account4 = @0x104
-    )]
-    #[expected_failure(abort_code = 0x10008, location = Self)]
-    fun weighted_invalid_members_length(
-        account1: signer, account2: signer, account3: signer
-    ) {
-        // create multisig wallet
-        let addr1 = signer::address_of(&account1);
-        let addr2 = signer::address_of(&account2);
-        let addr3 = signer::address_of(&account3);
-
-        create_weighted_multisig_account(
-            &account1,
-            string::utf8(b"multisig wallet"),
-            vector[string::utf8(b"admin"), string::utf8(b"member")],
-            vector[2, 1],
-            vector[addr1, addr2, addr3],
-            vector[string::utf8(b"admin"), string::utf8(b"member")],
-            2
-        );
-    }
-
-    #[test(
-        account1 = @0x101, account2 = @0x102, account3 = @0x103, account4 = @0x104
-    )]
-    #[expected_failure(abort_code = 0x10009, location = Self)]
-    fun weighted_invalid_members_tiers(
-        account1: signer, account2: signer, account3: signer
-    ) {
-        // create multisig wallet
-        let addr1 = signer::address_of(&account1);
-        let addr2 = signer::address_of(&account2);
-        let addr3 = signer::address_of(&account3);
-
-        create_weighted_multisig_account(
-            &account1,
-            string::utf8(b"multisig wallet"),
-            vector[string::utf8(b"admin"), string::utf8(b"member")],
-            vector[2, 1],
-            vector[addr1, addr2, addr3],
-            vector[
-                string::utf8(b"admin"),
-                string::utf8(b"member"),
-                string::utf8(b"god")
-            ],
-            2
-        );
-    }
-
-    #[test(
-        account1 = @0x101, account2 = @0x102, account3 = @0x103, account4 = @0x104
-    )]
-    #[expected_failure(abort_code = 0x10001, location = Self)]
-    fun weighted_invalid_threshold(
-        account1: signer, account2: signer, account3: signer
-    ) {
-        // create multisig wallet
-        let addr1 = signer::address_of(&account1);
-        let addr2 = signer::address_of(&account2);
-        let addr3 = signer::address_of(&account3);
-
-        create_weighted_multisig_account(
-            &account1,
-            string::utf8(b"multisig wallet"),
-            vector[string::utf8(b"admin"), string::utf8(b"member")],
-            vector[10, 1],
-            vector[addr1, addr2, addr3],
-            vector[
-                string::utf8(b"admin"),
-                string::utf8(b"admin"),
-                string::utf8(b"member")
-            ],
-            22
-        );
-    }
-
-    // test create weight multisig wallet successfully, check keys in object
-    #[test(
-        account1 = @0x101, account2 = @0x102, account3 = @0x103, account4 = @0x104
-    )]
-    fun create_weighted_wallet_success(
-        account1: signer, account2: signer, account3: signer
-    ) acquires MultisigWallet {
-        // create multisig wallet
-        let addr1 = signer::address_of(&account1);
-        let addr2 = signer::address_of(&account2);
-        let addr3 = signer::address_of(&account3);
-
-        let member_tiers = vector[
-            string::utf8(b"admin"),
-            string::utf8(b"member"),
-            string::utf8(b"member")
-        ];
-
-        create_weighted_multisig_account(
-            &account1,
-            string::utf8(b"multisig wallet"),
-            vector[string::utf8(b"admin"), string::utf8(b"member")],
-            vector[2, 1],
-            vector[addr1, addr2, addr3],
-            member_tiers,
-            2
-        );
-
-        let multisig_addr = get_multisig_address(
-            &addr1, &string::utf8(b"multisig wallet")
-        );
-        let multisig_wallet = borrow_global<MultisigWallet>(multisig_addr);
-        assert!(
-            vector::length(&multisig_wallet.members) == 3,
-            error::invalid_state(EINVALID_MEMBERS_LENGTH)
-        );
-
-        // assert each member tier is correct
-        let index = 0;
-        vector::for_each_ref(
-            &multisig_wallet.members,
-            |member| {
-                let tier_name = *vector::borrow(&member_tiers, index);
-                index = index + 1;
-
-                let m: &Member = member;
-                let tier = option::borrow(&m.tier);
-                assert!(tier_name == tier.name, 1)
-            }
-        );
-
-        // assert if multisig_wallet.tiers is not none and length is 2
-        let tiers = option::borrow(&multisig_wallet.tiers);
-        assert!(
-            vector::length(tiers) == 2,
-            error::invalid_state(EINVALID_TIERS_LENGTH)
-        );
-
-        assert!(
-            multisig_wallet.threshold == 2,
-            error::invalid_state(EINVALID_THRESHOLD)
-        );
-
-        assert!(
-            multisig_wallet.weighted,
-            error::invalid_state(1)
-        );
-    }
-
-    // test total_weight(members)
-    #[test(account1 = @0x101, account2 = @0x102, account3 = @0x103)]
-    fun total_weight_test(
-        account1: signer, account2: signer, account3: signer
-    ) acquires MultisigWallet {
-        let addr1 = signer::address_of(&account1);
-        let addr2 = signer::address_of(&account2);
-        let addr3 = signer::address_of(&account3);
-
-        create_weighted_multisig_account(
-            &account1,
-            string::utf8(b"multisig wallet"),
-            vector[string::utf8(b"admin"), string::utf8(b"member")],
-            vector[2, 1],
-            vector[addr1, addr2, addr3],
-            vector[
-                string::utf8(b"admin"),
-                string::utf8(b"member"),
-                string::utf8(b"member")
-            ],
-            2
-        );
-
-        let multisig_addr = get_multisig_address(
-            &addr1, &string::utf8(b"multisig wallet")
-        );
-        let multisig_wallet = borrow_global<MultisigWallet>(multisig_addr);
-
-        let total_weight = total_weight(&multisig_wallet.members);
-        assert!(total_weight == 4, 1);
-    }
-
-    #[test(
-        account1 = @0x101, account2 = @0x102, account3 = @0x103, account4 = @0x104
-    )]
-    #[expected_failure(abort_code = 0x50002, location = Self)]
-    fun create_proposal_by_other(
-        account1: signer,
-        account2: signer,
-        account3: signer,
-        account4: signer
-    ) acquires MultisigWallet {
-        // create multisig wallet
-        let addr1 = signer::address_of(&account1);
-        let addr2 = signer::address_of(&account2);
-        let addr3 = signer::address_of(&account3);
-        let addr4 = signer::address_of(&account4);
-
-        create_non_weighted_multisig_account(
-            &account1,
-            string::utf8(b"multisig wallet"),
-            vector[addr1, addr2, addr3],
-            2
-        );
-        let multisig_addr = get_multisig_address(
-            &addr1, &string::utf8(b"multisig wallet")
-        );
-
-        create_proposal(
-            &account4,
-            multisig_addr,
-            vector[@initia_std],
-            vector[string::utf8(b"multisig_v2")],
-            vector[string::utf8(b"update_config")],
-            vector[vector[]],
-            vector[
-                vector[
-                    std::bcs::to_bytes(&vector[addr1, addr2, addr4]),
-                    std::bcs::to_bytes(&3u64),
-                    std::bcs::to_bytes(&option::none<u64>()),
-                    std::bcs::to_bytes(&option::none<u64>())
-                ]
-            ],
-            option::none()
-        );
-    }
-
-    #[test(
-        account1 = @0x101, account2 = @0x102, account3 = @0x103, account4 = @0x104
-    )]
-    #[expected_failure(abort_code = 0x1000c, location = Self)]
-    fun invalid_list_create_proposal(
-        account1: signer,
-        account2: signer,
-        account3: signer,
-        account4: signer
-    ) acquires MultisigWallet {
-        // create multisig wallet
-        let addr1 = signer::address_of(&account1);
-        let addr2 = signer::address_of(&account2);
-        let addr3 = signer::address_of(&account3);
-        let addr4 = signer::address_of(&account4);
-
-        create_non_weighted_multisig_account(
-            &account1,
-            string::utf8(b"multisig wallet"),
-            vector[addr1, addr2, addr3],
-            2
-        );
-        let multisig_addr = get_multisig_address(
-            &addr1, &string::utf8(b"multisig wallet")
-        );
-
-        create_proposal(
-            &account4,
-            multisig_addr,
-            vector[@initia_std],
-            vector[string::utf8(b"multisig_v2"), string::utf8(b"multisig_v2")],
-            vector[string::utf8(b"update_config")],
-            vector[vector[]],
-            vector[
-                vector[
-                    std::bcs::to_bytes(&vector[addr1, addr2, addr4]),
-                    std::bcs::to_bytes(&3u64),
-                    std::bcs::to_bytes(&option::none<u64>()),
-                    std::bcs::to_bytes(&option::none<u64>())
-                ]
-            ],
-            option::none()
-        );
-    }
-
-    #[test(
-        account1 = @0x101, account2 = @0x102, account3 = @0x103, account4 = @0x104
-    )]
-    fun create_proposal_successfully(
-        account1: signer,
-        account2: signer,
-        account3: signer,
-        account4: signer
-    ) acquires MultisigWallet {
-        // create multisig wallet
-        let addr1 = signer::address_of(&account1);
-        let addr2 = signer::address_of(&account2);
-        let addr3 = signer::address_of(&account3);
-        let addr4 = signer::address_of(&account4);
-
-        create_non_weighted_multisig_account(
-            &account1,
-            string::utf8(b"multisig wallet"),
-            vector[addr1, addr2, addr3],
-            2
-        );
-        let multisig_addr = get_multisig_address(
-            &addr1, &string::utf8(b"multisig wallet")
-        );
-
-        set_block_info(100, 100);
-
-        create_proposal(
-            &account1,
-            multisig_addr,
-            vector[@initia_std],
-            vector[string::utf8(b"multisig_v2")],
-            vector[string::utf8(b"update_config")],
-            vector[vector[]],
-            vector[
-                vector[
-                    std::bcs::to_bytes(&vector[addr1, addr2, addr4]),
-                    std::bcs::to_bytes(&3u64),
-                    std::bcs::to_bytes(&option::none<u64>()),
-                    std::bcs::to_bytes(&option::none<u64>())
-                ]
-            ],
-            option::some(99)
-        );
-
-        // borrow proposal from multisig wallet
-        let multisig_wallet = borrow_global<MultisigWallet>(multisig_addr);
-        let proposal = table::borrow(&multisig_wallet.proposals, 1);
-
-        let expected_votes = simple_map::create<Member, bool>();
-        simple_map::add(
-            &mut expected_votes,
-            get_member_by_address(multisig_wallet.members, addr1),
-            true
-        );
-
-        assert!(
-            proposal.proposer == get_member_by_address(multisig_wallet.members, addr1),
-            1
-        );
-        assert!(proposal.proposed_height == 100, 1);
-        assert!(proposal.proposed_timestamp == 100, 1);
-        assert!(
-            *option::borrow(&proposal.expiry_timestamp) == 199,
-            1
-        );
-        assert!(proposal.status == 0, 1);
-        assert!(proposal.is_json == false, 1);
-
-        let execute_message = vector::borrow(&proposal.execute_messages, 0);
-        assert!(vector::length(&execute_message.json_args) == 0, 1);
-        assert!(
-            &execute_message.args
-                == &vector[
-                    std::bcs::to_bytes(&vector[addr1, addr2, addr4]),
-                    std::bcs::to_bytes(&3u64),
-                    std::bcs::to_bytes(&option::none<u64>()),
-                    std::bcs::to_bytes(&option::none<u64>())
-                ],
-            1
-        );
-
-        assert!(vector::length(&execute_message.type_args) == 0, 1);
-        assert!(execute_message.module_address == @initia_std, 1);
-        assert!(
-            execute_message.module_name == string::utf8(b"multisig_v2"),
-            1
-        );
-        assert!(
-            execute_message.function_name == string::utf8(b"update_config"),
-            1
-        );
-        assert!(
-            proposal.threshold == multisig_wallet.threshold,
-            1
-        );
-        assert!(proposal.total_weight == 3, 1);
-        assert!(
-            yes_vote_score(&proposal.votes, &multisig_wallet.members) == 1,
-            1
-        );
-    }
-
-    // test proposal_to_proposal_response for weight multisig wallet
-    #[test(
-        account1 = @0x101, account2 = @0x102, account3 = @0x103, account4 = @0x104
-    )]
-    fun proposal_to_proposal_response_weighted(
-        account1: signer,
-        account2: signer,
-        account3: signer,
-        account4: signer
-    ) acquires MultisigWallet {
-        // create multisig wallet
-        let addr1 = signer::address_of(&account1);
-        let addr2 = signer::address_of(&account2);
-        let addr3 = signer::address_of(&account3);
-        let addr4 = signer::address_of(&account4);
-
-        create_weighted_multisig_account(
-            &account1,
-            string::utf8(b"multisig wallet"),
-            vector[string::utf8(b"admin"), string::utf8(b"member")],
-            vector[2, 1],
-            vector[addr1, addr2, addr3],
-            vector[
-                string::utf8(b"admin"),
-                string::utf8(b"member"),
-                string::utf8(b"member")
-            ],
-            2
-        );
-        let multisig_addr = get_multisig_address(
-            &addr1, &string::utf8(b"multisig wallet")
-        );
-
-        set_block_info(100, 100);
-
-        create_proposal(
-            &account1,
-            multisig_addr,
-            vector[@initia_std],
-            vector[string::utf8(b"multisig_v2")],
-            vector[string::utf8(b"update_config")],
-            vector[vector[]],
-            vector[
-                vector[
-                    std::bcs::to_bytes(&vector[addr1, addr2, addr4]),
-                    std::bcs::to_bytes(&3u64),
-                    std::bcs::to_bytes(&option::none<u64>()),
-                    std::bcs::to_bytes(&option::none<u64>())
-                ]
-            ],
-            option::some(99)
-        );
-
-        let multisig_wallet = borrow_global<MultisigWallet>(multisig_addr);
-        let proposal = table::borrow(&multisig_wallet.proposals, 1);
-
-        let proposal_response =
-            proposal_to_proposal_response(multisig_wallet, multisig_addr, 1, proposal);
-
-        let expected_proposal_response = ProposalResponse {
-            multisig_addr,
-            proposal_id: 1,
-            proposer: get_member_by_address(multisig_wallet.members, addr1),
-            proposed_height: 100,
-            proposed_timestamp: 100,
-            expiry_timestamp: option::some(199),
-            votes: proposal.votes,
-            threshold: 2,
-            total_weight: 4,
-            yes_vote_score: 2,
-            status: string::utf8(b"voting"),
-            is_json: false,
-            execute_messages: vector[
-                ExecuteMessage {
-                    module_address: @initia_std,
-                    module_name: string::utf8(b"multisig_v2"),
-                    function_name: string::utf8(b"update_config"),
-                    type_args: vector[],
-                    args: vector[
-                        std::bcs::to_bytes(&vector[addr1, addr2, addr4]),
-                        std::bcs::to_bytes(&3u64),
-                        std::bcs::to_bytes(&option::none<u64>()),
-                        std::bcs::to_bytes(&option::none<u64>())
-                    ],
-                    json_args: vector[]
-                }
-            ]
-        };
-
-        assert!(
-            proposal_response == expected_proposal_response,
-            1
-        );
-    }
-
-    #[test(account1 = @0x101, account2 = @0x102, account3 = @0x103)]
-    fun proposal_with_json(
-        account1: signer, account2: signer, account3: signer
-    ) acquires MultisigWallet {
-        // create multisig wallet
-        let addr1 = signer::address_of(&account1);
-        let addr2 = signer::address_of(&account2);
-        let addr3 = signer::address_of(&account3);
-
-        create_non_weighted_multisig_account(
-            &account1,
-            string::utf8(b"multisig wallet"),
-            vector[addr1, addr2, addr3],
-            2
-        );
-        let multisig_addr = get_multisig_address(
-            &addr1, &string::utf8(b"multisig wallet")
-        );
-
-        create_proposal_with_json(
-            &account1,
-            multisig_addr,
-            vector[@initia_std],
-            vector[string::utf8(b"multisig_v2")],
-            vector[string::utf8(b"update_config")],
-            vector[vector[]],
-            vector[
-                vector[
-                    string::utf8(b"[\"0x101\", \"0x102\", \"0x104\"]"),
-                    string::utf8(b"\"3\""),
-                    string::utf8(b""),
-                    string::utf8(b"")
-                ]
-            ],
-            option::some(99)
-        );
-
-        let proposal = get_proposal(multisig_addr, 1);
-        let execute_message = vector::borrow(&proposal.execute_messages, 0);
-
-        assert!(execute_message.module_address == @initia_std, 0);
-        assert!(
-            execute_message.module_name == string::utf8(b"multisig_v2"),
-            1
-        );
-        assert!(
-            execute_message.function_name == string::utf8(b"update_config"),
-            2
-        );
-        assert!(execute_message.type_args == vector[], 3);
-        assert!(
-            execute_message.json_args
-                == vector[
-                    string::utf8(b"[\"0x101\", \"0x102\", \"0x104\"]"),
-                    string::utf8(b"\"3\""),
-                    string::utf8(b""),
-                    string::utf8(b"")
-                ],
-            4
-        );
-        assert!(execute_message.args == vector[], 5);
-    }
-
-    #[test(
-        account1 = @0x101, account2 = @0x102, account3 = @0x103, account4 = @0x104
-    )]
-    #[expected_failure(abort_code = 0x50002, location = Self)]
-    fun vote_by_other(
-        account1: signer,
-        account2: signer,
-        account3: signer,
-        account4: signer
-    ) acquires MultisigWallet {
-        // create multisig wallet
-        let addr1 = signer::address_of(&account1);
-        let addr2 = signer::address_of(&account2);
-        let addr3 = signer::address_of(&account3);
-        let addr4 = signer::address_of(&account4);
-
-        create_non_weighted_multisig_account(
-            &account1,
-            string::utf8(b"multisig wallet"),
-            vector[addr1, addr2, addr3],
-            2
-        );
-
-        let multisig_addr = get_multisig_address(
-            &addr1, &string::utf8(b"multisig wallet")
-        );
-
-        set_block_info(100, 100);
-        create_proposal(
-            &account1,
-            multisig_addr,
-            vector[@initia_std],
-            vector[string::utf8(b"multisig_v2")],
-            vector[string::utf8(b"update_config")],
-            vector[vector[]],
-            vector[
-                vector[
-                    std::bcs::to_bytes(&vector[addr1, addr2, addr4]),
-                    std::bcs::to_bytes(&3u64),
-                    std::bcs::to_bytes(&option::none<u64>()),
-                    std::bcs::to_bytes(&option::none<u64>())
-                ]
-            ],
-            option::some(99)
-        );
-
-        vote_proposal(&account4, multisig_addr, 1, true);
-    }
-
-    #[test(
-        account1 = @0x101, account2 = @0x102, account3 = @0x103, account4 = @0x104
-    )]
-    #[expected_failure(abort_code = 0x30004, location = Self)]
-    fun vote_after_proposal_expired(
-        account1: signer,
-        account2: signer,
-        account3: signer,
-        account4: signer
-    ) acquires MultisigWallet {
-        // create multisig wallet
-        let addr1 = signer::address_of(&account1);
-        let addr2 = signer::address_of(&account2);
-        let addr3 = signer::address_of(&account3);
-        let addr4 = signer::address_of(&account4);
-
-        create_non_weighted_multisig_account(
-            &account1,
-            string::utf8(b"multisig wallet"),
-            vector[addr1, addr2, addr3],
-            2
-        );
-        let multisig_addr = get_multisig_address(
-            &addr1, &string::utf8(b"multisig wallet")
-        );
-
-        set_block_info(100, 100);
-        create_proposal(
-            &account1,
-            multisig_addr,
-            vector[@initia_std],
-            vector[string::utf8(b"multisig_v2")],
-            vector[string::utf8(b"update_config")],
-            vector[vector[]],
-            vector[
-                vector[
-                    std::bcs::to_bytes(&vector[addr1, addr2, addr4]),
-                    std::bcs::to_bytes(&3u64),
-                    std::bcs::to_bytes(&option::none<u64>()),
-                    std::bcs::to_bytes(&option::none<u64>())
-                ]
-            ],
-            option::some(99)
-        );
-
-        set_block_info(100, 199);
-        vote_proposal(&account2, multisig_addr, 1, true);
-    }
-
-    #[test(
-        account1 = @0x101, account2 = @0x102, account3 = @0x103, account4 = @0x104
-    )]
-    fun vote_proposal_of_non_weighted_multisig_successfully(
-        account1: signer,
-        account2: signer,
-        account3: signer,
-        account4: signer
-    ) acquires MultisigWallet {
-        // create multisig wallet
-        let addr1 = signer::address_of(&account1);
-        let addr2 = signer::address_of(&account2);
-        let addr3 = signer::address_of(&account3);
-        let addr4 = signer::address_of(&account4);
-
-        create_non_weighted_multisig_account(
-            &account1,
-            string::utf8(b"multisig wallet"),
-            vector[addr1, addr2, addr3],
-            2
-        );
-        let multisig_addr = get_multisig_address(
-            &addr1, &string::utf8(b"multisig wallet")
-        );
-
-        set_block_info(100, 100);
-        create_proposal(
-            &account1,
-            multisig_addr,
-            vector[@initia_std],
-            vector[string::utf8(b"multisig_v2")],
-            vector[string::utf8(b"update_config")],
-            vector[vector[]],
-            vector[
-                vector[
-                    std::bcs::to_bytes(&vector[addr1, addr2, addr4]),
-                    std::bcs::to_bytes(&3u64),
-                    std::bcs::to_bytes(&option::none<u64>()),
-                    std::bcs::to_bytes(&option::none<u64>())
-                ]
-            ],
-            option::some(99)
-        );
-
-        vote_proposal(&account1, multisig_addr, 1, true);
-        vote_proposal(&account2, multisig_addr, 1, false);
-        vote_proposal(&account3, multisig_addr, 1, true);
-
-        let multisig_wallet = borrow_global<MultisigWallet>(multisig_addr);
-        let proposal = table::borrow(&multisig_wallet.proposals, 1);
-        let proposal_response =
-            proposal_to_proposal_response(multisig_wallet, multisig_addr, 1, proposal);
-
-        let expected_votes =
-            create_votes_map(
-                multisig_wallet.members,
-                vector[true, false, true]
-            );
-
-        assert!(proposal_response.votes == expected_votes, 1);
-
-        assert!(proposal_response.yes_vote_score == 2, 1);
-
-        assert!(proposal_response.total_weight == 3, 1);
-    }
-
-    #[test(
-        account1 = @0x101, account2 = @0x102, account3 = @0x103, account4 = @0x104
-    )]
-    fun vote_proposal_of_weighted_multisig_successfully(
-        account1: signer,
-        account2: signer,
-        account3: signer,
-        account4: signer
-    ) acquires MultisigWallet {
-        // create multisig wallet
-        let addr1 = signer::address_of(&account1);
-        let addr2 = signer::address_of(&account2);
-        let addr3 = signer::address_of(&account3);
-        let addr4 = signer::address_of(&account4);
-
-        create_weighted_multisig_account(
-            &account1,
-            string::utf8(b"multisig wallet"),
-            vector[string::utf8(b"admin"), string::utf8(b"member")],
-            vector[2, 1],
-            vector[addr1, addr2, addr3],
-            vector[
-                string::utf8(b"admin"),
-                string::utf8(b"member"),
-                string::utf8(b"member")
-            ],
-            2
-        );
-        let multisig_addr = get_multisig_address(
-            &addr1, &string::utf8(b"multisig wallet")
-        );
-
-        set_block_info(100, 100);
-        create_proposal(
-            &account1,
-            multisig_addr,
-            vector[@initia_std],
-            vector[string::utf8(b"multisig_v2")],
-            vector[string::utf8(b"update_config")],
-            vector[vector[]],
-            vector[
-                vector[
-                    std::bcs::to_bytes(&vector[addr1, addr2, addr4]),
-                    std::bcs::to_bytes(&3u64),
-                    std::bcs::to_bytes(&option::none<u64>()),
-                    std::bcs::to_bytes(&option::none<u64>())
-                ]
-            ],
-            option::some(99)
-        );
-
-        vote_proposal(&account1, multisig_addr, 1, true);
-        vote_proposal(&account2, multisig_addr, 1, false);
-        vote_proposal(&account3, multisig_addr, 1, true);
-
-        let multisig_wallet = borrow_global<MultisigWallet>(multisig_addr);
-        let proposal = table::borrow(&multisig_wallet.proposals, 1);
-        let proposal_response =
-            proposal_to_proposal_response(multisig_wallet, multisig_addr, 1, proposal);
-
-        let expected_votes =
-            create_votes_map(
-                multisig_wallet.members,
-                vector[true, false, true]
-            );
-
-        assert!(proposal_response.votes == expected_votes, 1);
-
-        assert!(proposal_response.yes_vote_score == 3, 1);
-
-        assert!(proposal_response.total_weight == 4, 1);
-    }
-
-    #[test(
-        account1 = @0x101, account2 = @0x102, account3 = @0x103, account4 = @0x104
-    )]
-    #[expected_failure(abort_code = 0x50002, location = Self)]
-    fun execute_by_others(
-        account1: signer,
-        account2: signer,
-        account3: signer,
-        account4: signer
-    ) acquires MultisigWallet {
-        // create multisig wallet
-        let addr1 = signer::address_of(&account1);
-        let addr2 = signer::address_of(&account2);
-        let addr3 = signer::address_of(&account3);
-        let addr4 = signer::address_of(&account4);
-
-        create_non_weighted_multisig_account(
-            &account1,
-            string::utf8(b"multisig wallet"),
-            vector[addr1, addr2, addr3],
-            2
-        );
-        let multisig_addr = get_multisig_address(
-            &addr1, &string::utf8(b"multisig wallet")
-        );
-
-        create_proposal(
-            &account1,
-            multisig_addr,
-            vector[@initia_std],
-            vector[string::utf8(b"multisig_v2")],
-            vector[string::utf8(b"update_config")],
-            vector[vector[]],
-            vector[
-                vector[
-                    std::bcs::to_bytes(&vector[addr1, addr2, addr4]),
-                    std::bcs::to_bytes(&3u64),
-                    std::bcs::to_bytes(&option::none<u64>()),
-                    std::bcs::to_bytes(&option::none<u64>())
-                ]
-            ],
-            option::some(99)
-        );
-
-        vote_proposal(&account1, multisig_addr, 1, true);
-        vote_proposal(&account2, multisig_addr, 1, false);
-        vote_proposal(&account3, multisig_addr, 1, false);
-
-        execute_proposal(&account4, multisig_addr, 1);
-    }
-
-    #[test(
-        account1 = @0x101, account2 = @0x102, account3 = @0x103, account4 = @0x104
-    )]
-    #[expected_failure(abort_code = 0x10006, location = Self)]
-    fun execute_on_a_non_existing_proposal(
-        account1: signer,
-        account2: signer,
-        account3: signer,
-        account4: signer
-    ) acquires MultisigWallet {
-        // create multisig wallet
-        let addr1 = signer::address_of(&account1);
-        let addr2 = signer::address_of(&account2);
-        let addr3 = signer::address_of(&account3);
-        let addr4 = signer::address_of(&account4);
-
-        create_non_weighted_multisig_account(
-            &account1,
-            string::utf8(b"multisig wallet"),
-            vector[addr1, addr2, addr3],
-            2
-        );
-        let multisig_addr = get_multisig_address(
-            &addr1, &string::utf8(b"multisig wallet")
-        );
-
-        create_proposal(
-            &account1,
-            multisig_addr,
-            vector[@initia_std],
-            vector[string::utf8(b"multisig_v2")],
-            vector[string::utf8(b"update_config")],
-            vector[vector[]],
-            vector[
-                vector[
-                    std::bcs::to_bytes(&vector[addr1, addr2, addr4]),
-                    std::bcs::to_bytes(&3u64),
-                    std::bcs::to_bytes(&option::none<u64>()),
-                    std::bcs::to_bytes(&option::none<u64>())
-                ]
-            ],
-            option::some(99)
-        );
-
-        execute_proposal(&account1, multisig_addr, 2);
-    }
-
-    #[test(
-        account1 = @0x101, account2 = @0x102, account3 = @0x103, account4 = @0x104
-    )]
-    #[expected_failure(abort_code = 0x30005, location = Self)]
-    fun non_weighted_multisig_execute_not_pass(
-        account1: signer,
-        account2: signer,
-        account3: signer,
-        account4: signer
-    ) acquires MultisigWallet {
-        // create multisig wallet
-        let addr1 = signer::address_of(&account1);
-        let addr2 = signer::address_of(&account2);
-        let addr3 = signer::address_of(&account3);
-        let addr4 = signer::address_of(&account4);
-
-        create_non_weighted_multisig_account(
-            &account1,
-            string::utf8(b"multisig wallet"),
-            vector[addr1, addr2, addr3],
-            2
-        );
-        let multisig_addr = get_multisig_address(
-            &addr1, &string::utf8(b"multisig wallet")
-        );
-
-        create_proposal(
-            &account1,
-            multisig_addr,
-            vector[@initia_std],
-            vector[string::utf8(b"multisig_v2")],
-            vector[string::utf8(b"update_config")],
-            vector[vector[]],
-            vector[
-                vector[
-                    std::bcs::to_bytes(&vector[addr1, addr2, addr4]),
-                    std::bcs::to_bytes(&3u64),
-                    std::bcs::to_bytes(&option::none<u64>()),
-                    std::bcs::to_bytes(&option::none<u64>())
-                ]
-            ],
-            option::some(99)
-        );
-
-        vote_proposal(&account1, multisig_addr, 1, true);
-        vote_proposal(&account2, multisig_addr, 1, false);
-        vote_proposal(&account3, multisig_addr, 1, false);
-
-        execute_proposal(&account1, multisig_addr, 1);
-    }
-
-    #[test(
-        account1 = @0x101, account2 = @0x102, account3 = @0x103, account4 = @0x104
-    )]
-    #[expected_failure(abort_code = 0x30005, location = Self)]
-    fun weighted_multisig_execute_not_pass(
-        account1: signer,
-        account2: signer,
-        account3: signer,
-        account4: signer
-    ) acquires MultisigWallet {
-        // create multisig wallet
-        let addr1 = signer::address_of(&account1);
-        let addr2 = signer::address_of(&account2);
-        let addr3 = signer::address_of(&account3);
-        let addr4 = signer::address_of(&account4);
-
-        create_weighted_multisig_account(
-            &account1,
-            string::utf8(b"multisig wallet"),
-            vector[string::utf8(b"admin"), string::utf8(b"member")],
-            vector[3, 2],
-            vector[addr1, addr2, addr3],
-            vector[
-                string::utf8(b"admin"),
-                string::utf8(b"member"),
-                string::utf8(b"member")
-            ],
-            6
-        );
-
-        let multisig_addr = get_multisig_address(
-            &addr1, &string::utf8(b"multisig wallet")
-        );
-
-        create_proposal(
-            &account1,
-            multisig_addr,
-            vector[@initia_std],
-            vector[string::utf8(b"multisig_v2")],
-            vector[string::utf8(b"update_config")],
-            vector[vector[]],
-            vector[
-                vector[
-                    std::bcs::to_bytes(&vector[addr1, addr2, addr4]),
-                    std::bcs::to_bytes(&3u64),
-                    std::bcs::to_bytes(&option::none<u64>()),
-                    std::bcs::to_bytes(&option::none<u64>())
-                ]
-            ],
-            option::some(99)
-        );
-
-        vote_proposal(&account1, multisig_addr, 1, true);
-        vote_proposal(&account2, multisig_addr, 1, false);
-        vote_proposal(&account3, multisig_addr, 1, true);
-
-        execute_proposal(&account1, multisig_addr, 1);
-    }
-
-    #[test(
-        account1 = @0x101, account2 = @0x102, account3 = @0x103, account4 = @0x104
-    )]
-    fun execute_pass_successfully(
-        account1: signer,
-        account2: signer,
-        account3: signer,
-        account4: signer
-    ) acquires MultisigWallet {
-        // create multisig wallet
-        let addr1 = signer::address_of(&account1);
-        let addr2 = signer::address_of(&account2);
-        let addr3 = signer::address_of(&account3);
-        let addr4 = signer::address_of(&account4);
-
-        create_weighted_multisig_account(
-            &account1,
-            string::utf8(b"multisig wallet"),
-            vector[string::utf8(b"admin"), string::utf8(b"member")],
-            vector[3, 2],
-            vector[addr1, addr2, addr3],
-            vector[
-                string::utf8(b"admin"),
-                string::utf8(b"member"),
-                string::utf8(b"member")
-            ],
-            5
-        );
-
-        let multisig_addr = get_multisig_address(
-            &addr1, &string::utf8(b"multisig wallet")
-        );
-
-        create_proposal(
-            &account1,
-            multisig_addr,
-            vector[@initia_std],
-            vector[string::utf8(b"multisig_v2")],
-            vector[string::utf8(b"update_config")],
-            vector[vector[]],
-            vector[
-                vector[
-                    std::bcs::to_bytes(&vector[addr1, addr2, addr4]),
-                    std::bcs::to_bytes(&3u64),
-                    std::bcs::to_bytes(&option::none<u64>()),
-                    std::bcs::to_bytes(&option::none<u64>())
-                ]
-            ],
-            option::some(99)
-        );
-
-        vote_proposal(&account1, multisig_addr, 1, true);
-        vote_proposal(&account2, multisig_addr, 1, false);
-        vote_proposal(&account3, multisig_addr, 1, true);
-
-        execute_proposal(&account1, multisig_addr, 1);
-    }
-
-    #[test(account1 = @0x101, account2 = @0x102, account3 = @0x103)]
-    #[expected_failure(abort_code = 0x10001, location = simple_map)]
-    fun update_config_duplicate_members(
-        account1: signer, account2: signer, account3: signer
-    ) acquires MultisigWallet {
-        // create multisig wallet
-        let addr1 = signer::address_of(&account1);
-        let addr2 = signer::address_of(&account2);
-        let addr3 = signer::address_of(&account3);
-
-        create_non_weighted_multisig_account(
-            &account1,
-            string::utf8(b"multisig wallet"),
-            vector[addr1, addr2, addr3],
-            2
-        );
-        let multisig_addr = get_multisig_address(
-            &addr1, &string::utf8(b"multisig wallet")
-        );
-        let multisig_wallet = borrow_global<MultisigWallet>(multisig_addr);
-        let multisig_signer =
-            &object::generate_signer_for_extending(&multisig_wallet.extend_ref);
-
-        update_config(
-            multisig_signer,
-            vector[addr1, addr2, addr3, addr3],
-            option::none(),
-            option::none(),
-            option::none(),
-            3
-        );
-    }
-
-    #[test(account1 = @0x101, account2 = @0x102, account3 = @0x103)]
-    #[expected_failure(abort_code = 0x10001, location = Self)]
-    fun update_config_non_weighted_invalid_threshold(
-        account1: signer, account2: signer, account3: signer
-    ) acquires MultisigWallet {
-        // create multisig wallet
-        let addr1 = signer::address_of(&account1);
-        let addr2 = signer::address_of(&account2);
-        let addr3 = signer::address_of(&account3);
-
-        create_non_weighted_multisig_account(
-            &account1,
-            string::utf8(b"multisig wallet"),
-            vector[addr1, addr2, addr3],
-            4
-        );
-        let multisig_addr = get_multisig_address(
-            &addr1, &string::utf8(b"multisig wallet")
-        );
-        let multisig_wallet = borrow_global<MultisigWallet>(multisig_addr);
-        let multisig_signer =
-            &object::generate_signer_for_extending(&multisig_wallet.extend_ref);
-
-        update_config(
-            multisig_signer,
-            vector[addr1, addr2, addr3, addr3],
-            option::none(),
-            option::none(),
-            option::none(),
-            3
-        );
-    }
-
-    #[test(account1 = @0x101, account2 = @0x102, account3 = @0x103)]
-    fun update_config_non_weighted_successfully(
-        account1: signer, account2: signer, account3: signer
-    ) acquires MultisigWallet {
-        // create multisig wallet
-        let addr1 = signer::address_of(&account1);
-        let addr2 = signer::address_of(&account2);
-        let addr3 = signer::address_of(&account3);
-
-        create_non_weighted_multisig_account(
-            &account1,
-            string::utf8(b"multisig wallet"),
-            vector[addr1, addr2, addr3],
-            2
-        );
-
-        let multisig_addr = get_multisig_address(
-            &addr1, &string::utf8(b"multisig wallet")
-        );
-
-        set_block_info(100, 100);
-
-        // proposal 1 : active proposal with votes from addr1, addr2, addr3
-        create_proposal(
-            &account1,
-            multisig_addr,
-            vector[@initia_std],
-            vector[string::utf8(b"multisig_v2")],
-            vector[string::utf8(b"update_config")],
-            vector[vector[]],
-            vector[
-                vector[
-                    std::bcs::to_bytes(&vector[addr1, addr2, addr3]), std::bcs::to_bytes(
-                        &3u64
-                    ), std::bcs::to_bytes(&option::none<u64>()), std::bcs::to_bytes(
-                        &option::none<u64>()
-                    ), std::bcs::to_bytes(&option::none<u64>())
-                ]
-            ],
-            option::some(99)
-        );
-
-        // vote on proposal 1 without execution
-        vote_proposal(&account1, multisig_addr, 1, true);
-        vote_proposal(&account2, multisig_addr, 1, false);
-        vote_proposal(&account3, multisig_addr, 1, true);
-
-        // proposal 2 : expired proposal with votes from addr1, addr2, addr3
-        create_proposal(
-            &account1,
-            multisig_addr,
-            vector[@initia_std],
-            vector[string::utf8(b"multisig_v2")],
-            vector[string::utf8(b"update_config")],
-            vector[vector[]],
-            vector[
-                vector[
-                    std::bcs::to_bytes(&vector[addr1, addr2, addr3]),
-                    std::bcs::to_bytes(&3u64),
-                    std::bcs::to_bytes(&option::none<u64>()),
-                    std::bcs::to_bytes(&option::none<u64>())
-                ]
-            ],
-            option::some(1)
-        );
-
-        // vote on proposal 2 without execution
-        vote_proposal(&account1, multisig_addr, 2, false);
-        vote_proposal(&account2, multisig_addr, 2, false);
-        vote_proposal(&account3, multisig_addr, 2, true);
-
-        // proposal 2 is now expired
-        set_block_info(100, 110);
-
-        // proposal 3 : executed proposal with votes from addr1, addr2, addr3
-        create_proposal(
-            &account1,
-            multisig_addr,
-            vector[@initia_std],
-            vector[string::utf8(b"multisig_v2")],
-            vector[string::utf8(b"update_config")],
-            vector[vector[]],
-            vector[
-                vector[
-                    std::bcs::to_bytes(&vector[addr1, addr2, addr3]),
-                    std::bcs::to_bytes(&3u64),
-                    std::bcs::to_bytes(&option::none<u64>()),
-                    std::bcs::to_bytes(&option::none<u64>())
-                ]
-            ],
-            option::some(99)
-        );
-
-        // vote on proposal 3 with execution
-        vote_proposal(&account1, multisig_addr, 3, true);
-        vote_proposal(&account2, multisig_addr, 3, false);
-        vote_proposal(&account3, multisig_addr, 3, true);
-        execute_proposal(&account1, multisig_addr, 3);
-
-        // update_config
-        let multisig_wallet = borrow_global<MultisigWallet>(multisig_addr);
-        let multisig_signer =
-            &object::generate_signer_for_extending(&multisig_wallet.extend_ref);
-        update_config(
-            multisig_signer,
-            vector[addr2, addr3],
-            option::none(),
-            option::none(),
-            option::none(),
-            1
-        );
-
-        // check if multisig wallet is updated
-        let updated_multisig_wallet = borrow_global<MultisigWallet>(multisig_addr);
-        assert!(
-            updated_multisig_wallet.members
-                == vector::map(
-                    vector[addr2, addr3],
-                    |addr| Member { address: addr, tier: option::none() }
-                ),
-            1
-        );
-        assert!(updated_multisig_wallet.threshold == 1, 1);
-
-        // proposal 1 details changed accordingly
-        let updated_proposal1 = get_proposal(multisig_addr, 1);
-        assert!(updated_proposal1.threshold == 1, 1);
-        assert!(updated_proposal1.total_weight == 2, 1);
-        assert!(
-            !simple_map::contains_key(
-                &updated_proposal1.votes, &Member { address: addr1, tier: option::none() }
-            ),
-            1
-        );
-        assert!(
-            simple_map::contains_key(
-                &updated_proposal1.votes, &Member { address: addr2, tier: option::none() }
-            ),
-            1
-        );
-        assert!(
-            simple_map::contains_key(
-                &updated_proposal1.votes, &Member { address: addr3, tier: option::none() }
-            ),
-            1
-        );
-
-        // proposal 2 (expired) details remain unchanged
-        let updated_proposal2 = get_proposal(multisig_addr, 2);
-        assert!(updated_proposal2.threshold == 2, 1);
-        assert!(updated_proposal2.total_weight == 3, 1);
-        assert!(
-            simple_map::contains_key(
-                &updated_proposal2.votes, &Member { address: addr1, tier: option::none() }
-            ),
-            1
-        );
-        assert!(
-            simple_map::contains_key(
-                &updated_proposal2.votes, &Member { address: addr2, tier: option::none() }
-            ),
-            1
-        );
-        assert!(
-            simple_map::contains_key(
-                &updated_proposal2.votes, &Member { address: addr3, tier: option::none() }
-            ),
-            1
-        );
-
-        // proposal 3 (executed) details remain unchanged
-        let updated_proposal3 = get_proposal(multisig_addr, 3);
-        assert!(updated_proposal3.threshold == 2, 1);
-        assert!(updated_proposal3.total_weight == 3, 1);
-        assert!(
-            simple_map::contains_key(
-                &updated_proposal3.votes, &Member { address: addr1, tier: option::none() }
-            ),
-            1
-        );
-        assert!(
-            simple_map::contains_key(
-                &updated_proposal3.votes, &Member { address: addr2, tier: option::none() }
-            ),
-            1
-        );
-        assert!(
-            simple_map::contains_key(
-                &updated_proposal3.votes, &Member { address: addr3, tier: option::none() }
-            ),
-            1
-        );
-    }
-}