create-dubhe 0.1.13 → 1.2.0-pre.51

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

@@ -1,1011 +0,0 @@
-module initia_std::multisig {
-    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};
-
-    // errors
-
-    const EINVALID_THRESHOLD: u64 = 1;
-
-    const ENOT_MEMBER: u64 = 2;
-
-    const EOLD_CONFIG_VERSION: u64 = 3;
-
-    const EINVALID_PROPOSAL_STATUS: u64 = 4;
-
-    const EPROPOSAL_EXPIRED: u64 = 5;
-
-    const EUPDATE_CONFIG_PROPOSAL_ALREADY_EXISTS: u64 = 6;
-
-    const EPROPOSAL_ALREADY_EXISTS: u64 = 7;
-
-    const ENOT_PASS: u64 = 8;
-
-    const EPROPOSAL_NOT_FOUND: u64 = 9;
-
-    // constants
-
-    const STATUS: vector<vector<u8>> = vector[b"in voting period", b"executed", b"expired"];
-
-    const MAX_LIMIT: u8 = 30;
-
-    // structs
-
-    /// `Period` represents a time period with optional expiry conditions.
-    /// If both `height` and `timestamp` are `None`, the period is considered to never expire.
-    /// If both `height` and `timestamp` are set, and only one of them has expired, the period is considered expired.
-    struct Period has copy, drop, store {
-        height: Option<u64>,
-        timestamp: Option<u64>
-    }
-
-    struct MultisigWallet has key {
-        extend_ref: ExtendRef,
-        config_version: u64, // config version
-        members: vector<address>, // members of multisig account
-        threshold: u64, // require votes to pass
-        max_voting_period: Period, // max voting period
-        proposals: Table<u64, Proposal>
-    }
-
-    struct Proposal has store {
-        module_address: address,
-        module_name: String,
-        function_name: String,
-        type_args: vector<String>,
-        args: vector<vector<u8>>,
-        config_version: u64,
-        proposal_timestamp: u64,
-        proposal_height: u64,
-        votes: SimpleMap<address, bool>,
-        status: u8,
-        is_json: bool,
-        json_args: vector<String>
-    }
-
-    // events
-
-    #[event]
-    struct CreateMultisigAccountEvent has drop, store {
-        multisig_addr: address,
-        members: vector<address>,
-        threshold: u64,
-        max_voting_period: Period
-    }
-
-    #[event]
-    struct CreateProposalEvent has drop, store {
-        multisig_addr: address,
-        proposal_id: u64,
-        module_address: address,
-        module_name: String,
-        function_name: String,
-        type_args: vector<String>,
-        args: vector<vector<u8>>,
-        config_version: u64
-    }
-
-    #[event]
-    struct VoteProposalEvent has drop, store {
-        multisig_addr: address,
-        proposal_id: u64,
-        voter: address,
-        vote_yes: bool
-    }
-
-    #[event]
-    struct ExecuteProposalEvent has drop, store {
-        multisig_addr: address,
-        proposal_id: u64,
-        executor: address
-    }
-
-    #[event]
-    struct UpdateConfigEvent has drop, store {
-        multisig_addr: address,
-        members: vector<address>,
-        threshold: u64,
-        max_voting_period: Period
-    }
-
-    // view function response struct
-
-    struct ProposalResponse has drop {
-        multisig_addr: address,
-        proposal_id: u64,
-        module_address: address,
-        module_name: String,
-        function_name: String,
-        type_args: vector<String>,
-        args: vector<vector<u8>>,
-        proposal_height: u64,
-        proposal_timestamp: u64,
-        config_version: u64,
-        yes_vote_count: u64,
-        status: String,
-        is_json: bool,
-        json_args: vector<String>
-    }
-
-    struct ConfigResponse has drop {
-        multisig_addr: address,
-        config_version: u64,
-        members: vector<address>,
-        threshold: u64,
-        max_voting_period: Period
-    }
-
-    // view functions
-    #[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
-    }
-
-    #[view]
-    public fun get_config(multisig_addr: address): ConfigResponse acquires MultisigWallet {
-        let multisig_wallet = borrow_global<MultisigWallet>(multisig_addr);
-
-        ConfigResponse {
-            multisig_addr,
-            config_version: multisig_wallet.config_version,
-            members: multisig_wallet.members,
-            threshold: multisig_wallet.threshold,
-            max_voting_period: multisig_wallet.max_voting_period
-        }
-    }
-
-    // entry functions
-
-    /// Create new multisig account
-    public entry fun create_multisig_account(
-        account: &signer,
-        name: String, // name for make deterministic multisig address (account_addr + name)
-        members: vector<address>,
-        threshold: u64,
-        max_voting_period_height: Option<u64>,
-        max_voting_period_timestamp: Option<u64>
-    ) {
-        assert_member(&members, &signer::address_of(account));
-        assert!(
-            vector::length(&members) >= threshold,
-            error::invalid_argument(EINVALID_THRESHOLD)
-        );
-        let constructor_ref = object::create_named_object(
-            account, *string::bytes(&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 max_voting_period = Period {
-            height: max_voting_period_height,
-            timestamp: max_voting_period_timestamp
-        };
-        let members_map = simple_map::create<address, bool>();
-        vector::for_each(
-            members,
-            |member| simple_map::add(&mut members_map, member, true)
-        ); // just for check uniqueness
-
-        move_to(
-            &multisig_signer,
-            MultisigWallet {
-                extend_ref,
-                config_version: 1,
-                members,
-                threshold,
-                max_voting_period,
-                proposals: table::new()
-            }
-        );
-
-        event::emit<CreateMultisigAccountEvent>(
-            CreateMultisigAccountEvent {
-                multisig_addr,
-                members,
-                threshold,
-                max_voting_period
-            }
-        )
-    }
-
-    /// Create new proposal
-    public entry fun create_proposal(
-        account: &signer,
-        multisig_addr: address,
-        module_address: address,
-        module_name: String,
-        function_name: String,
-        type_args: vector<String>,
-        args: vector<vector<u8>>
-    ) acquires MultisigWallet {
-        create_proposal_internal(
-            account,
-            multisig_addr,
-            module_address,
-            module_name,
-            function_name,
-            type_args,
-            args,
-            false,
-            vector[]
-        )
-    }
-
-    /// Create new proposal
-    public entry fun create_proposal_with_json(
-        account: &signer,
-        multisig_addr: address,
-        module_address: address,
-        module_name: String,
-        function_name: String,
-        type_args: vector<String>,
-        args: vector<String>
-    ) acquires MultisigWallet {
-        create_proposal_internal(
-            account,
-            multisig_addr,
-            module_address,
-            module_name,
-            function_name,
-            type_args,
-            vector[],
-            true,
-            args
-        )
-    }
-
-    /// Vote proposal
-    public entry fun vote_proposal(
-        account: &signer,
-        multisig_addr: address,
-        proposal_id: u64,
-        vote_yes: bool
-    ) acquires MultisigWallet {
-        let voter = signer::address_of(account);
-        let multisig_wallet = borrow_global_mut<MultisigWallet>(multisig_addr);
-        assert_member(&multisig_wallet.members, &voter);
-
-        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_config_version(multisig_wallet.config_version, proposal);
-        assert_proposal(&multisig_wallet.max_voting_period, proposal);
-
-        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 = signer::address_of(account);
-        let multisig_wallet = borrow_global_mut<MultisigWallet>(multisig_addr);
-        assert_member(&multisig_wallet.members, &executor);
-
-        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_config_version(multisig_wallet.config_version, proposal);
-        assert_proposal(&multisig_wallet.max_voting_period, proposal);
-
-        // check passed
-        assert!(
-            yes_vote_count(&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);
-
-        if (!proposal.is_json) {
-            move_execute(
-                multisig_signer,
-                proposal.module_address,
-                proposal.module_name,
-                proposal.function_name,
-                proposal.type_args,
-                proposal.args
-            )
-        } else {
-            move_execute_with_json(
-                multisig_signer,
-                proposal.module_address,
-                proposal.module_name,
-                proposal.function_name,
-                proposal.type_args,
-                proposal.json_args
-            )
-        };
-
-        proposal.status = 1; // executed
-
-        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_threshold: u64,
-        new_max_voting_period_height: Option<u64>,
-        new_max_voting_period_timestamp: Option<u64>
-    ) acquires MultisigWallet {
-        let multisig_addr = signer::address_of(account);
-        let multisig_wallet = borrow_global_mut<MultisigWallet>(multisig_addr);
-
-        assert!(
-            vector::length(&new_members) >= new_threshold,
-            error::invalid_argument(EINVALID_THRESHOLD)
-        );
-        let new_members_map = simple_map::create<address, bool>();
-        vector::for_each(
-            new_members,
-            |member| simple_map::add(&mut new_members_map, member, true)
-        ); // just for check uniqueness
-        let new_max_voting_period = Period {
-            height: new_max_voting_period_height,
-            timestamp: new_max_voting_period_timestamp
-        };
-
-        multisig_wallet.config_version = multisig_wallet.config_version + 1;
-        multisig_wallet.members = new_members;
-        multisig_wallet.threshold = new_threshold;
-        multisig_wallet.max_voting_period = new_max_voting_period;
-
-        event::emit<UpdateConfigEvent>(
-            UpdateConfigEvent {
-                multisig_addr,
-                members: new_members,
-                threshold: new_threshold,
-                max_voting_period: new_max_voting_period
-            }
-        )
-    }
-
-    fun create_proposal_internal(
-        account: &signer,
-        multisig_addr: address,
-        module_address: address,
-        module_name: String,
-        function_name: String,
-        type_args: vector<String>,
-        args: vector<vector<u8>>,
-        is_json: bool,
-        json_args: vector<String>
-    ) acquires MultisigWallet {
-        let addr = signer::address_of(account);
-        let multisig_wallet = borrow_global_mut<MultisigWallet>(multisig_addr);
-        assert_member(&multisig_wallet.members, &addr);
-
-        let (height, timestamp) = get_block_info();
-        let config_version = multisig_wallet.config_version;
-
-        let proposal = Proposal {
-            module_address,
-            module_name,
-            function_name,
-            type_args,
-            args,
-            config_version,
-            proposal_height: height,
-            proposal_timestamp: timestamp,
-            votes: simple_map::create(),
-            status: 0, // in voting period
-            is_json,
-            json_args
-        };
-
-        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,
-                module_address,
-                module_name,
-                function_name,
-                type_args,
-                args,
-                config_version
-            }
-        )
-    }
-
-    fun is_proposal_expired(
-        max_period: &Period, proposal_height: u64, proposal_timestamp: u64
-    ): bool {
-        let (height, timestamp) = get_block_info();
-        let expired_height =
-            if (option::is_some(&max_period.height)) {
-                let max_voting_period_height = *option::borrow(&max_period.height);
-                (max_voting_period_height + proposal_height) >= height
-            } else { false };
-
-        let expired_timestamp =
-            if (option::is_some(&max_period.timestamp)) {
-                let max_voting_period_timestamp = *option::borrow(&max_period.timestamp);
-                (max_voting_period_timestamp + proposal_timestamp) >= timestamp
-            } else { false };
-
-        expired_height || expired_timestamp
-    }
-
-    fun vote(
-        votes: &mut SimpleMap<address, bool>,
-        voter: address,
-        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_count(
-        votes: &SimpleMap<address, bool>, members: &vector<address>
-    ): u64 {
-        let yes_count = 0;
-        vector::for_each_ref(
-            members,
-            |member| {
-                if (simple_map::contains_key(votes, member)
-                    && *simple_map::borrow(votes, member)) {
-                    yes_count = yes_count + 1;
-                }
-            }
-        );
-
-        yes_count
-    }
-
-    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(
-                &multisig_wallet.max_voting_period,
-                proposal.proposal_height,
-                proposal.proposal_timestamp
-            );
-        let yes_vote_count = yes_vote_count(&proposal.votes, &multisig_wallet.members);
-        if (status_index == 0 && is_expired) {
-            status_index = 2
-        };
-
-        ProposalResponse {
-            multisig_addr,
-            proposal_id,
-            module_address: proposal.module_address,
-            module_name: proposal.module_name,
-            function_name: proposal.function_name,
-            type_args: proposal.type_args,
-            args: proposal.args,
-            proposal_height: proposal.proposal_height,
-            proposal_timestamp: proposal.proposal_timestamp,
-            config_version: proposal.config_version,
-            yes_vote_count,
-            status: string::utf8(*vector::borrow(&STATUS, (status_index as u64))),
-            is_json: proposal.is_json,
-            json_args: proposal.json_args
-        }
-    }
-
-    inline fun assert_member(members: &vector<address>, member: &address) {
-        assert!(
-            vector::contains(members, member),
-            error::permission_denied(ENOT_MEMBER)
-        )
-    }
-
-    inline fun assert_config_version(
-        multisig_wallet_config_version: u64, execute_proposal: &Proposal
-    ) {
-        assert!(
-            multisig_wallet_config_version == execute_proposal.config_version,
-            error::invalid_state(EOLD_CONFIG_VERSION)
-        )
-    }
-
-    inline fun assert_proposal(
-        max_voting_period: &Period, proposal: &Proposal
-    ) {
-        assert!(
-            proposal.status == 0,
-            error::invalid_state(EINVALID_PROPOSAL_STATUS)
-        );
-        assert!(
-            !is_proposal_expired(
-                max_voting_period,
-                proposal.proposal_height,
-                proposal.proposal_timestamp
-            ),
-            error::invalid_state(EPROPOSAL_EXPIRED)
-        );
-    }
-
-    #[test_only]
-    use initia_std::block::set_block_info;
-
-    #[test(
-        account1 = @0x101, account2 = @0x102, account3 = @0x103, account4 = @0x104
-    )]
-    #[expected_failure(abort_code = 0x50002, location = Self)]
-    fun create_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_multisig_account(
-            &account4,
-            string::utf8(b"multisig wallet"),
-            vector[addr1, addr2, addr3],
-            2,
-            option::none(),
-            option::none()
-        );
-    }
-
-    #[test(account1 = @0x101, account2 = @0x102, account3 = @0x103)]
-    #[expected_failure(abort_code = 0x10001, location = Self)]
-    fun 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_multisig_account(
-            &account1,
-            string::utf8(b"multisig wallet"),
-            vector[addr1, addr2, addr3],
-            4,
-            option::none(),
-            option::none()
-        );
-    }
-
-    #[test(account1 = @0x101, account2 = @0x102, account3 = @0x103)]
-    #[expected_failure(abort_code = 0x10001, location = simple_map)]
-    fun duplicated_member(
-        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_multisig_account(
-            &account1,
-            string::utf8(b"multisig wallet"),
-            vector[addr1, addr1, addr2, addr3],
-            3,
-            option::none(),
-            option::none()
-        );
-    }
-
-    #[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_multisig_account(
-            &account1,
-            string::utf8(b"multisig wallet"),
-            vector[addr1, addr2, addr3],
-            2,
-            option::none(),
-            option::none()
-        );
-        let multisig_addr = object::create_object_address(&addr1, b"multisig wallet");
-
-        create_proposal(
-            &account4,
-            multisig_addr,
-            @initia_std,
-            string::utf8(b"mltisig"),
-            string::utf8(b"update_config"),
-            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>())
-            ]
-        );
-    }
-
-    #[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_multisig_account(
-            &account1,
-            string::utf8(b"multisig wallet"),
-            vector[addr1, addr2, addr3],
-            2,
-            option::none(),
-            option::none()
-        );
-        let multisig_addr = object::create_object_address(&addr1, b"multisig wallet");
-
-        create_proposal(
-            &account1,
-            multisig_addr,
-            @initia_std,
-            string::utf8(b"mltisig"),
-            string::utf8(b"update_config"),
-            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>())
-            ]
-        );
-
-        vote_proposal(&account4, multisig_addr, 1, true);
-    }
-
-    #[test(
-        account1 = @0x101, account2 = @0x102, account3 = @0x103, account4 = @0x104
-    )]
-    #[expected_failure(abort_code = 0x30005, location = Self)]
-    fun vote_after_height_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_multisig_account(
-            &account1,
-            string::utf8(b"multisig wallet"),
-            vector[addr1, addr2, addr3],
-            2,
-            option::some(10),
-            option::some(10)
-        );
-        let multisig_addr = object::create_object_address(&addr1, b"multisig wallet");
-
-        set_block_info(100, 100);
-        create_proposal(
-            &account1,
-            multisig_addr,
-            @initia_std,
-            string::utf8(b"mltisig"),
-            string::utf8(b"update_config"),
-            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>())
-            ]
-        );
-
-        set_block_info(111, 100);
-        vote_proposal(&account1, multisig_addr, 1, true);
-    }
-
-    #[test(
-        account1 = @0x101, account2 = @0x102, account3 = @0x103, account4 = @0x104
-    )]
-    #[expected_failure(abort_code = 0x30005, location = Self)]
-    fun vote_after_timestamp_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_multisig_account(
-            &account1,
-            string::utf8(b"multisig wallet"),
-            vector[addr1, addr2, addr3],
-            2,
-            option::some(10),
-            option::some(10)
-        );
-        let multisig_addr = object::create_object_address(&addr1, b"multisig wallet");
-
-        set_block_info(100, 100);
-        create_proposal(
-            &account1,
-            multisig_addr,
-            @initia_std,
-            string::utf8(b"mltisig"),
-            string::utf8(b"update_config"),
-            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>())
-            ]
-        );
-
-        set_block_info(100, 111);
-        vote_proposal(&account1, multisig_addr, 1, true);
-    }
-
-    #[test(
-        account1 = @0x101, account2 = @0x102, account3 = @0x103, account4 = @0x104
-    )]
-    #[expected_failure(abort_code = 0x30008, location = Self)]
-    fun 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_multisig_account(
-            &account1,
-            string::utf8(b"multisig wallet"),
-            vector[addr1, addr2, addr3],
-            2,
-            option::none(),
-            option::none()
-        );
-        let multisig_addr = object::create_object_address(&addr1, b"multisig wallet");
-
-        create_proposal(
-            &account1,
-            multisig_addr,
-            @initia_std,
-            string::utf8(b"mltisig"),
-            string::utf8(b"update_config"),
-            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>())
-            ]
-        );
-
-        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 = 0x30003, location = Self)]
-    fun execute_after_config_update(
-        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_multisig_account(
-            &account1,
-            string::utf8(b"multisig wallet"),
-            vector[addr1, addr2, addr3],
-            2,
-            option::none(),
-            option::none()
-        );
-        let multisig_addr = object::create_object_address(&addr1, b"multisig wallet");
-
-        create_proposal(
-            &account1,
-            multisig_addr,
-            @initia_std,
-            string::utf8(b"mltisig"),
-            string::utf8(b"update_config"),
-            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>())
-            ]
-        );
-
-        vote_proposal(&account1, multisig_addr, 1, true);
-        vote_proposal(&account2, multisig_addr, 1, true);
-        vote_proposal(&account3, multisig_addr, 1, false);
-
-        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, addr4],
-            2,
-            option::none(),
-            option::none()
-        );
-
-        execute_proposal(&account1, multisig_addr, 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_multisig_account(
-            &account1,
-            string::utf8(b"multisig wallet"),
-            vector[addr1, addr2, addr3],
-            2,
-            option::none(),
-            option::none()
-        );
-        let multisig_addr = object::create_object_address(&addr1, b"multisig wallet");
-
-        create_proposal_with_json(
-            &account1,
-            multisig_addr,
-            @initia_std,
-            string::utf8(b"multisig"),
-            string::utf8(b"update_config"),
-            vector[],
-            vector[
-                string::utf8(b"[\"0x101\", \"0x102\", \"0x104\"]"),
-                string::utf8(b"\"3\""),
-                string::utf8(b""),
-                string::utf8(b"")
-            ]
-        );
-
-        let proposal = get_proposal(multisig_addr, 1);
-        assert!(proposal.module_address == @initia_std, 0);
-        assert!(
-            proposal.module_name == string::utf8(b"multisig"),
-            1
-        );
-        assert!(
-            proposal.function_name == string::utf8(b"update_config"),
-            2
-        );
-        assert!(proposal.type_args == vector[], 3);
-        assert!(
-            proposal.json_args
-                == vector[
-                    string::utf8(b"[\"0x101\", \"0x102\", \"0x104\"]"),
-                    string::utf8(b"\"3\""),
-                    string::utf8(b""),
-                    string::utf8(b"")
-                ],
-            4
-        );
-        assert!(proposal.args == vector[], 5);
-    }
-}