Merge pull request #125 from icehawk-hyb/multisig

plugin/dapp/init/init.go

@@ -7,6 +7,7 @@ import (
 	_ "github.com/33cn/plugin/plugin/dapp/game"       //auto gen
 	_ "github.com/33cn/plugin/plugin/dapp/hashlock"   //auto gen
 	_ "github.com/33cn/plugin/plugin/dapp/lottery"    //auto gen
+	_ "github.com/33cn/plugin/plugin/dapp/multisig"   //auto gen
 	_ "github.com/33cn/plugin/plugin/dapp/norm"       //auto gen
 	_ "github.com/33cn/plugin/plugin/dapp/paracross"  //auto gen
 	_ "github.com/33cn/plugin/plugin/dapp/pokerbull"  //auto gen

plugin/dapp/multisig/commands/multisig.go

+// Copyright Fuzamei Corp. 2018 All Rights Reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package commands
+
+import (
+	"fmt"
+	"math"
+	"os"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/33cn/chain33/rpc/jsonclient"
+	rpctypes "github.com/33cn/chain33/rpc/types"
+	"github.com/33cn/chain33/types"
+	mty "github.com/33cn/plugin/plugin/dapp/multisig/types"
+	"github.com/spf13/cobra"
+)
+
+//MultiSigCmd :
+func MultiSigCmd() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "multisig",
+		Short: "multisig management",
+		Args:  cobra.MinimumNArgs(1),
+	}
+	cmd.AddCommand(
+		MultiSigAccountCmd(),
+		MultiSigOwnerCmd(),
+		MultiSigTxCmd(),
+	)
+	return cmd
+}
+
+//MultiSigAccountCmd :account相关的命令
+func MultiSigAccountCmd() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "account",
+		Short: "multisig account",
+		Args:  cobra.MinimumNArgs(1),
+	}
+	cmd.AddCommand(
+		CreateMultiSigAccCreateCmd(),
+		CreateMultiSigAccWeightModifyCmd(),
+		CreateMultiSigAccDailyLimitModifyCmd(),
+		GetMultiSigAccCountCmd(),
+		GetMultiSigAccountsCmd(),
+		GetMultiSigAccountInfoCmd(),
+		GetMultiSigAccUnSpentTodayCmd(),
+		GetMultiSigAccAssetsCmd(),
+		GetMultiSigAccAllAddressCmd(),
+	)
+	return cmd
+}
+
+//MultiSigOwnerCmd : owner相关的命令
+func MultiSigOwnerCmd() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "owner",
+		Short: "multisig owner",
+		Args:  cobra.MinimumNArgs(1),
+	}
+	cmd.AddCommand(
+		CreateMultiSigAccOwnerAddCmd(),
+		CreateMultiSigAccOwnerDelCmd(),
+		CreateMultiSigAccOwnerModifyCmd(),
+		CreateMultiSigAccOwnerReplaceCmd(),
+	)
+	return cmd
+}
+
+//MultiSigTxCmd : tx交易相关的命令
+func MultiSigTxCmd() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "tx",
+		Short: "multisig tx",
+		Args:  cobra.MinimumNArgs(1),
+	}
+	cmd.AddCommand(
+		CreateMultiSigConfirmTxCmd(),
+		CreateMultiSigAccTransferInCmd(),
+		CreateMultiSigAccTransferOutCmd(),
+		GetMultiSigAccTxCountCmd(),
+		GetMultiSigTxidsCmd(),
+		GetMultiSigTxInfoCmd(),
+		GetMultiSigTxConfirmedWeightCmd(),
+	)
+	return cmd
+}
+
+// CreateMultiSigAccCreateCmd create raw MultiSigAccCreate transaction
+func CreateMultiSigAccCreateCmd() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "create",
+		Short: "Create a multisig account transaction",
+		Run:   createMultiSigAccTransfer,
+	}
+	createMultiSigAccTransferFlags(cmd)
+	return cmd
+}
+
+func createMultiSigAccTransferFlags(cmd *cobra.Command) {
+
+	cmd.Flags().StringP("owners_addr", "a", "", "address of owner,separated by space")
+	cmd.MarkFlagRequired("owners_addr")
+
+	cmd.Flags().StringP("owners_weight", "w", "", "weight of owner,separated by space,uint64 type")
+	cmd.MarkFlagRequired("owners_weight")
+
+	cmd.Flags().Uint64P("required_weight", "r", 0, "required weight of account execute tx")
+	cmd.MarkFlagRequired("required_weight")
+
+	cmd.Flags().StringP("execer", "e", "", "assets execer name")
+	cmd.MarkFlagRequired("execer")
+
+	cmd.Flags().StringP("symbol", "s", "", "assets symbol")
+	cmd.MarkFlagRequired("symbol")
+
+	cmd.Flags().Float64P("daily_limit", "d", 0, "daily_limit of assets ")
+	cmd.MarkFlagRequired("daily_limit")
+}
+
+func createMultiSigAccTransfer(cmd *cobra.Command, args []string) {
+	rpcLaddr, _ := cmd.Flags().GetString("rpc_laddr")
+
+	address, _ := cmd.Flags().GetString("owners_addr")
+	addressArr := strings.Fields(address)
+
+	weightstr, _ := cmd.Flags().GetString("owners_weight")
+	weightsArr := strings.Fields(weightstr)
+
+	//校验owner和权重数量要一致
+	if len(addressArr) != len(weightsArr) {
+		fmt.Fprintln(os.Stderr, "len of owners_addr mismatch len of owners_weight")
+		return
+	}
+
+	//将字符转权重转换成uint64的值
+	var weights []uint64
+	var totalweight uint64
+	var ownerCount int
+	for _, weight := range weightsArr {
+		ownerweight, err := strconv.ParseInt(weight, 10, 64)
+		if err != nil || ownerweight <= 0 {
+			fmt.Fprintln(os.Stderr, "weight invalid")
+			return
+		}
+		weights = append(weights, uint64(ownerweight))
+		totalweight += uint64(ownerweight)
+		ownerCount = ownerCount + 1
+	}
+	var owners []*mty.Owner
+	for index, addr := range addressArr {
+		if addr != "" {
+			owmer := &mty.Owner{OwnerAddr: addr, Weight: weights[index]}
+			owners = append(owners, owmer)
+		}
+	}
+
+	requiredweight, err := cmd.Flags().GetUint64("required_weight")
+	if err != nil || requiredweight == 0 {
+		fmt.Fprintln(os.Stderr, "required weight invalid")
+		return
+	}
+	if requiredweight > totalweight {
+		fmt.Fprintln(os.Stderr, "Requiredweight more than totalweight")
+		return
+	}
+
+	execer, _ := cmd.Flags().GetString("execer")
+	symbol, _ := cmd.Flags().GetString("symbol")
+
+	dailylimit, _ := cmd.Flags().GetFloat64("daily_limit")
+	err = isValidDailylimit(dailylimit)
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		return
+	}
+	symboldailylimit := &mty.SymbolDailyLimit{
+		Symbol:     symbol,
+		Execer:     execer,
+		DailyLimit: uint64(math.Trunc((dailylimit+0.0000001)*1e4)) * 1e4,
+	}
+
+	params := &mty.MultiSigAccCreate{
+		Owners:         owners,
+		RequiredWeight: requiredweight,
+		DailyLimit:     symboldailylimit,
+	}
+	var res string
+	ctx := jsonclient.NewRPCCtx(rpcLaddr, "multisig.MultiSigAccCreateTx", params, &res)
+	ctx.RunWithoutMarshal()
+}
+
+// CreateMultiSigAccOwnerAddCmd create raw MultiSigAccOwnerAdd transaction
+func CreateMultiSigAccOwnerAddCmd() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "add",
+		Short: "Create a add owner  transaction",
+		Run:   createOwnerAddTransfer,
+	}
+	createOwnerAddTransferFlags(cmd)
+	return cmd
+}
+
+func createOwnerAddTransferFlags(cmd *cobra.Command) {
+
+	cmd.Flags().StringP("multisig_addr", "a", "", "address of multisig account")
+	cmd.MarkFlagRequired("multisig_addr")
+
+	cmd.Flags().StringP("owner_addr", "o", "", "address of owner")
+	cmd.MarkFlagRequired("owner_addr")
+
+	cmd.Flags().Uint64P("owner_weight", "w", 0, "weight of owner")
+	cmd.MarkFlagRequired("owner_weight")
+
+}
+
+func createOwnerAddTransfer(cmd *cobra.Command, args []string) {
+	rpcLaddr, _ := cmd.Flags().GetString("rpc_laddr")
+	multiSigAddr, _ := cmd.Flags().GetString("multisig_addr")
+	ownerAddr, _ := cmd.Flags().GetString("owner_addr")
+	ownerWeight, _ := cmd.Flags().GetUint64("owner_weight")
+
+	params := &mty.MultiSigOwnerOperate{
+		MultiSigAccAddr: multiSigAddr,
+		NewOwner:        ownerAddr,
+		NewWeight:       ownerWeight,
+		OperateFlag:     mty.OwnerAdd,
+	}
+	var res string
+	ctx := jsonclient.NewRPCCtx(rpcLaddr, "multisig.MultiSigOwnerOperateTx", params, &res)
+	ctx.RunWithoutMarshal()
+}
+
+// CreateMultiSigAccOwnerDelCmd create raw MultiSigAccOwnerDel transaction
+func CreateMultiSigAccOwnerDelCmd() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "del",
+		Short: "Create a del owner transaction",
+		Run:   createOwnerDelTransfer,
+	}
+	createOwnerDelTransferFlags(cmd)
+	return cmd
+}
+
+func createOwnerDelTransferFlags(cmd *cobra.Command) {
+
+	cmd.Flags().StringP("multisig_addr", "a", "", "address of multisig account")
+	cmd.MarkFlagRequired("multisig_addr")
+
+	cmd.Flags().StringP("owner_addr", "o", "", "address of owner")
+	cmd.MarkFlagRequired("owner_addr")
+}
+
+func createOwnerDelTransfer(cmd *cobra.Command, args []string) {
+	rpcLaddr, _ := cmd.Flags().GetString("rpc_laddr")
+	multiSigAddr, _ := cmd.Flags().GetString("multisig_addr")
+	ownerAddr, _ := cmd.Flags().GetString("owner_addr")
+
+	params := &mty.MultiSigOwnerOperate{
+		MultiSigAccAddr: multiSigAddr,
+		OldOwner:        ownerAddr,
+		OperateFlag:     mty.OwnerDel,
+	}
+	var res string
+	ctx := jsonclient.NewRPCCtx(rpcLaddr, "multisig.MultiSigOwnerOperateTx", params, &res)
+	ctx.RunWithoutMarshal()
+}
+
+// CreateMultiSigAccOwnerModifyCmd create raw MultiSigAccOwnerDel transaction
+func CreateMultiSigAccOwnerModifyCmd() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "modify",
+		Short: "Create a modify owner weight transaction",
+		Run:   createOwnerModifyTransfer,
+	}
+	createOwnerModifyTransferFlags(cmd)
+	return cmd
+}
+
+func createOwnerModifyTransferFlags(cmd *cobra.Command) {
+
+	cmd.Flags().StringP("multisig_addr", "a", "", "address of multisig account")
+	cmd.MarkFlagRequired("multisig_addr")
+	cmd.Flags().StringP("owner_addr", "o", "", "address of owner")
+	cmd.MarkFlagRequired("owner_addr")
+	cmd.Flags().Uint64P("owner_weight", "w", 0, "new weight of owner")
+	cmd.MarkFlagRequired("owner_weight")
+}
+
+func createOwnerModifyTransfer(cmd *cobra.Command, args []string) {
+	rpcLaddr, _ := cmd.Flags().GetString("rpc_laddr")
+	multiSigAddr, _ := cmd.Flags().GetString("multisig_addr")
+	ownerAddr, _ := cmd.Flags().GetString("owner_addr")
+	ownerWeight, _ := cmd.Flags().GetUint64("owner_weight")
+
+	params := &mty.MultiSigOwnerOperate{
+		MultiSigAccAddr: multiSigAddr,
+		OldOwner:        ownerAddr,
+		NewWeight:       ownerWeight,
+		OperateFlag:     mty.OwnerModify,
+	}
+	var res string
+	ctx := jsonclient.NewRPCCtx(rpcLaddr, "multisig.MultiSigOwnerOperateTx", params, &res)
+	ctx.RunWithoutMarshal()
+}
+
+// CreateMultiSigAccOwnerReplaceCmd create raw MultiSigAccOwnerReplace transaction
+func CreateMultiSigAccOwnerReplaceCmd() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "replace",
+		Short: "Create a replace owner transaction",
+		Run:   createOwnerReplaceTransfer,
+	}
+	createOwnerReplaceTransferFlags(cmd)
+	return cmd
+}
+
+func createOwnerReplaceTransferFlags(cmd *cobra.Command) {
+
+	cmd.Flags().StringP("multisig_addr", "a", "", "address of multisig account")
+	cmd.MarkFlagRequired("multisig_addr")
+	cmd.Flags().StringP("owner_addr", "o", "", "address of old owner")
+	cmd.MarkFlagRequired("owner_addr")
+	cmd.Flags().StringP("new_owner", "n", "", "address of new owner")
+	cmd.MarkFlagRequired("new_owner")
+}
+
+func createOwnerReplaceTransfer(cmd *cobra.Command, args []string) {
+	rpcLaddr, _ := cmd.Flags().GetString("rpc_laddr")
+	multiSigAddr, _ := cmd.Flags().GetString("multisig_addr")
+	ownerAddr, _ := cmd.Flags().GetString("owner_addr")
+	newOwner, _ := cmd.Flags().GetString("new_owner")
+
+	params := &mty.MultiSigOwnerOperate{
+		MultiSigAccAddr: multiSigAddr,
+		OldOwner:        ownerAddr,
+		NewOwner:        newOwner,
+		OperateFlag:     mty.OwnerReplace,
+	}
+	var res string
+	ctx := jsonclient.NewRPCCtx(rpcLaddr, "multisig.MultiSigOwnerOperateTx", params, &res)
+	ctx.RunWithoutMarshal()
+}
+
+// CreateMultiSigAccWeightModifyCmd create raw CreateMultiSigAccWeightModifyCmd transaction
+func CreateMultiSigAccWeightModifyCmd() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "weight",
+		Short: "Create a modify required weight transaction",
+		Run:   createMultiSigAccWeightModifyTransfer,
+	}
+	createMultiSigAccWeightModifyTransferFlags(cmd)
+	return cmd
+}
+
+func createMultiSigAccWeightModifyTransferFlags(cmd *cobra.Command) {
+
+	cmd.Flags().StringP("multisig_addr", "a", "", "address of multisig account")
+	cmd.MarkFlagRequired("multisig_addr")
+	cmd.Flags().Uint64P("weight", "w", 0, "new required weight of multisig account ")
+}
+
+func createMultiSigAccWeightModifyTransfer(cmd *cobra.Command, args []string) {
+	rpcLaddr, _ := cmd.Flags().GetString("rpc_laddr")
+	multiSigAddr, _ := cmd.Flags().GetString("multisig_addr")
+	weight, _ := cmd.Flags().GetUint64("weight")
+
+	params := &mty.MultiSigAccOperate{
+		MultiSigAccAddr:   multiSigAddr,
+		NewRequiredWeight: weight,
+		OperateFlag:       mty.AccWeightOp,
+	}
+	var res string
+	ctx := jsonclient.NewRPCCtx(rpcLaddr, "multisig.MultiSigAccOperateTx", params, &res)
+	ctx.RunWithoutMarshal()
+}
+
+// CreateMultiSigAccDailyLimitModifyCmd create raw MultiSigAccDailyLimitModify transaction
+func CreateMultiSigAccDailyLimitModifyCmd() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "dailylimit",
+		Short: "Create a modify assets dailylimit transaction",
+		Run:   createMultiSigAccDailyLimitModifyTransfer,
+	}
+	createMultiSigAccDailyLimitModifyTransferFlags(cmd)
+	return cmd
+}
+
+func createMultiSigAccDailyLimitModifyTransferFlags(cmd *cobra.Command) {
+
+	cmd.Flags().StringP("multisig_addr", "a", "", "address of multisig account")
+	cmd.MarkFlagRequired("multisig_addr")
+
+	cmd.Flags().StringP("execer", "e", "", "assets execer name")
+	cmd.MarkFlagRequired("execer")
+
+	cmd.Flags().StringP("symbol", "s", "", "assets symbol")
+	cmd.MarkFlagRequired("symbol")
+
+	cmd.Flags().Float64P("daily_limit", "d", 0, "daily_limit of assets ")
+	cmd.MarkFlagRequired("daily_limit")
+}
+
+func createMultiSigAccDailyLimitModifyTransfer(cmd *cobra.Command, args []string) {
+	rpcLaddr, _ := cmd.Flags().GetString("rpc_laddr")
+	multiSigAddr, _ := cmd.Flags().GetString("multisig_addr")
+	execer, _ := cmd.Flags().GetString("execer")
+	symbol, _ := cmd.Flags().GetString("symbol")
+	dailylimit, _ := cmd.Flags().GetFloat64("daily_limit")
+
+	err := isValidDailylimit(dailylimit)
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		return
+	}
+	assetsDailyLimit := &mty.SymbolDailyLimit{
+		Symbol:     symbol,
+		Execer:     execer,
+		DailyLimit: uint64(math.Trunc((dailylimit+0.0000001)*1e4)) * 1e4,
+	}
+	params := &mty.MultiSigAccOperate{
+		MultiSigAccAddr: multiSigAddr,
+		DailyLimit:      assetsDailyLimit,
+		OperateFlag:     mty.AccDailyLimitOp,
+	}
+	var res string
+	ctx := jsonclient.NewRPCCtx(rpcLaddr, "multisig.MultiSigAccOperateTx", params, &res)
+	ctx.RunWithoutMarshal()
+}
+
+// CreateMultiSigConfirmTxCmd create raw MultiSigConfirmTxCmd transaction
+func CreateMultiSigConfirmTxCmd() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "confirm",
+		Short: "Create a confirm transaction",
+		Run:   createMultiSigConfirmTransfer,
+	}
+	createMultiSigConfirmTransferFlags(cmd)
+	return cmd
+}
+
+func createMultiSigConfirmTransferFlags(cmd *cobra.Command) {
+
+	cmd.Flags().StringP("multisig_addr", "a", "", "address of multisig account")
+	cmd.MarkFlagRequired("multisig_addr")
+
+	cmd.Flags().Uint64P("txid", "i", 0, "txid of  multisig transaction")
+	cmd.MarkFlagRequired("txid")
+
+	cmd.Flags().StringP("confirm_or_revoke", "c", "t", "whether confirm or revoke tx (0/f/false for No; 1/t/true for Yes)")
+
+}
+
+func createMultiSigConfirmTransfer(cmd *cobra.Command, args []string) {
+	rpcLaddr, _ := cmd.Flags().GetString("rpc_laddr")
+	multiSigAddr, _ := cmd.Flags().GetString("multisig_addr")
+	txid, _ := cmd.Flags().GetUint64("txid")
+
+	confirmOrRevoke, _ := cmd.Flags().GetString("confirm_or_revoke")
+	confirmOrRevokeBool, err := strconv.ParseBool(confirmOrRevoke)
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		return
+	}
+
+	params := &mty.MultiSigConfirmTx{
+		MultiSigAccAddr: multiSigAddr,
+		TxId:            txid,
+		ConfirmOrRevoke: confirmOrRevokeBool,
+	}
+	var res string
+	ctx := jsonclient.NewRPCCtx(rpcLaddr, "multisig.MultiSigConfirmTx", params, &res)
+	ctx.RunWithoutMarshal()
+}
+
+// CreateMultiSigAccTransferInCmd create raw MultiSigAccTransferInCmd transaction
+func CreateMultiSigAccTransferInCmd() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "transfer_in",
+		Short: "Create a transfer to multisig account transaction",
+		Run:   createMultiSigAccTransferIn,
+	}
+	createMultiSigAccTransferInFlags(cmd)
+	return cmd
+}
+
+func createMultiSigAccTransferInFlags(cmd *cobra.Command) {
+	cmd.Flags().StringP("to", "t", "", "address of multisig account")
+	cmd.MarkFlagRequired("to")
+
+	cmd.Flags().StringP("execer", "e", "", "assets  execer")
+	cmd.MarkFlagRequired("execer")
+
+	cmd.Flags().StringP("symbol", "s", "", "assets symbol")
+	cmd.MarkFlagRequired("symbol")
+
+	cmd.Flags().StringP("note", "n", "", "transaction note info")
+
+	cmd.Flags().Float64P("amount", "a", 0, "transaction amount")
+	cmd.MarkFlagRequired("amount")
+}
+
+func createMultiSigAccTransferIn(cmd *cobra.Command, args []string) {
+	rpcLaddr, _ := cmd.Flags().GetString("rpc_laddr")
+	to, _ := cmd.Flags().GetString("to")
+	execer, _ := cmd.Flags().GetString("execer")
+	symbol, _ := cmd.Flags().GetString("symbol")
+	note, _ := cmd.Flags().GetString("note")
+	amount, _ := cmd.Flags().GetFloat64("amount")
+
+	if float64(types.MaxCoin/types.Coin) < amount {
+		fmt.Fprintln(os.Stderr, types.ErrAmount)
+		return
+	}
+	params := &mty.MultiSigExecTransferTo{
+		Symbol:   symbol,
+		Amount:   int64(math.Trunc((amount+0.0000001)*1e4)) * 1e4,
+		Note:     note,
+		Execname: execer,
+		To:       to,
+	}
+	var res string
+	ctx := jsonclient.NewRPCCtx(rpcLaddr, "multisig.MultiSigAccTransferInTx", params, &res)
+	ctx.RunWithoutMarshal()
+}
+
+// CreateMultiSigAccTransferOutCmd create raw MultiSigAccTransferOut transaction
+func CreateMultiSigAccTransferOutCmd() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "transfer_out",
+		Short: "Create a transfer from multisig account transaction",
+		Run:   createMultiSigAccTransferOut,
+	}
+	createMultiSigAccTransferOutFlags(cmd)
+	return cmd
+}
+
+func createMultiSigAccTransferOutFlags(cmd *cobra.Command) {
+
+	cmd.Flags().StringP("from", "f", "", "address of multisig account")
+	cmd.MarkFlagRequired("from")
+
+	cmd.Flags().StringP("to", "t", "", "address of account")
+	cmd.MarkFlagRequired("to")
+
+	cmd.Flags().StringP("execer", "e", "", "assets execer")
+	cmd.MarkFlagRequired("execer")
+
+	cmd.Flags().StringP("symbol", "s", "", "assets symbol")
+	cmd.MarkFlagRequired("symbol")
+
+	cmd.Flags().StringP("note", "n", "", "transaction note info")
+
+	cmd.Flags().Float64P("amount", "a", 0, "transaction amount")
+	cmd.MarkFlagRequired("amount")
+}
+
+func createMultiSigAccTransferOut(cmd *cobra.Command, args []string) {
+	rpcLaddr, _ := cmd.Flags().GetString("rpc_laddr")
+	from, _ := cmd.Flags().GetString("from")
+	to, _ := cmd.Flags().GetString("to")
+	execer, _ := cmd.Flags().GetString("execer")
+	symbol, _ := cmd.Flags().GetString("symbol")
+	note, _ := cmd.Flags().GetString("note")
+	amount, _ := cmd.Flags().GetFloat64("amount")
+
+	if float64(types.MaxCoin/types.Coin) < amount {
+		fmt.Fprintln(os.Stderr, types.ErrAmount)
+		return
+	}
+	params := &mty.MultiSigExecTransferFrom{
+		Symbol:   symbol,
+		Amount:   int64(math.Trunc((amount+0.0000001)*1e4)) * 1e4,
+		Note:     note,
+		Execname: execer,
+		From:     from,
+		To:       to,
+	}
+	var res string
+	ctx := jsonclient.NewRPCCtx(rpcLaddr, "multisig.MultiSigAccTransferOutTx", params, &res)
+	ctx.RunWithoutMarshal()
+}
+
+//GetMultiSigAccCountCmd 获取已经创建的多重签名账户数量
+func GetMultiSigAccCountCmd() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "count",
+		Short: "get multisig account count",
+		Run:   getMultiSigAccCount,
+	}
+	return cmd
+}
+
+func getMultiSigAccCount(cmd *cobra.Command, args []string) {
+	rpcLaddr, _ := cmd.Flags().GetString("rpc_laddr")
+
+	var params rpctypes.Query4Jrpc
+
+	var rep interface{}
+
+	params.Execer = mty.MultiSigX
+	params.FuncName = "MultiSigAccCount"
+	params.Payload = types.MustPBToJSON(&types.ReqNil{})
+	rep = &types.Int64{}
+	ctx := jsonclient.NewRPCCtx(rpcLaddr, "Chain33.Query", params, rep)
+	ctx.Run()
+}
+
+//GetMultiSigAccountsCmd 获取已经创建的多重签名账户地址，通过转入的index
+func GetMultiSigAccountsCmd() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "address",
+		Short: "get multisig account address",
+		Run:   getMultiSigAccounts,
+	}
+	addgetMultiSigAccountsFlags(cmd)
+	return cmd
+}
+
+func addgetMultiSigAccountsFlags(cmd *cobra.Command) {
+
+	cmd.Flags().Int64P("start", "s", 0, "account start index")
+	cmd.MarkFlagRequired("start")
+
+	cmd.Flags().Int64P("end", "e", 0, "account end index")
+	cmd.MarkFlagRequired("end")
+}
+
+func getMultiSigAccounts(cmd *cobra.Command, args []string) {
+	rpcLaddr, _ := cmd.Flags().GetString("rpc_laddr")
+
+	start, _ := cmd.Flags().GetInt64("start")
+	end, _ := cmd.Flags().GetInt64("end")
+
+	if start > end || start < 0 {
+		fmt.Fprintln(os.Stderr, "input parameter invalid!")
+		return
+	}
+	req := mty.ReqMultiSigAccs{
+		Start: start,
+		End:   end,
+	}
+
+	var params rpctypes.Query4Jrpc
+	var rep interface{}
+
+	params.Execer = mty.MultiSigX
+	params.FuncName = "MultiSigAccounts"
+	params.Payload = types.MustPBToJSON(&req)
+	rep = &mty.ReplyMultiSigAccs{}
+	ctx := jsonclient.NewRPCCtx(rpcLaddr, "Chain33.Query", params, rep)
+	ctx.Run()
+}
+
+//GetMultiSigAccountInfoCmd 获取已经创建的多重签名账户信息
+func GetMultiSigAccountInfoCmd() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "info",
+		Short: "get multisig account info",
+		Run:   getMultiSigAccountInfo,
+	}
+	getMultiSigAccountInfoFlags(cmd)
+	return cmd
+}
+
+func getMultiSigAccountInfoFlags(cmd *cobra.Command) {
+	cmd.Flags().StringP("addr", "a", "", "address of multisig account")
+	cmd.MarkFlagRequired("addr")
+}
+
+func getMultiSigAccountInfo(cmd *cobra.Command, args []string) {
+	rpcLaddr, _ := cmd.Flags().GetString("rpc_laddr")
+	addr, _ := cmd.Flags().GetString("addr")
+
+	req := mty.ReqMultiSigAccInfo{
+		MultiSigAccAddr: addr,
+	}
+
+	var params rpctypes.Query4Jrpc
+	var rep interface{}
+
+	params.Execer = mty.MultiSigX
+	params.FuncName = "MultiSigAccountInfo"
+	params.Payload = types.MustPBToJSON(&req)
+	rep = &mty.MultiSig{}
+	ctx := jsonclient.NewRPCCtx(rpcLaddr, "Chain33.Query", params, rep)
+	ctx.SetResultCb(parseAccInfo)
+	ctx.Run()
+}
+
+func parseAccInfo(view interface{}) (interface{}, error) {
+	res := view.(*mty.MultiSig)
+	var dailyLimitResults []*mty.DailyLimitResult
+
+	for _, dailyLimit := range res.DailyLimits {
+		dailyLimt := strconv.FormatFloat(float64(dailyLimit.DailyLimit)/float64(types.Coin), 'f', 4, 64)
+		spentToday := strconv.FormatFloat(float64(dailyLimit.SpentToday)/float64(types.Coin), 'f', 4, 64)
+		fmt.Println("parseAccInfo dailyLimt", dailyLimt)
+		dailyLimitResult := &mty.DailyLimitResult{
+			Symbol:     dailyLimit.Symbol,
+			Execer:     dailyLimit.Execer,
+			DailyLimit: dailyLimt,
+			SpentToday: spentToday,
+			LastDay:    time.Unix(dailyLimit.LastDay, 0).Format("2006-01-02 15:04:05"),
+		}
+		dailyLimitResults = append(dailyLimitResults, dailyLimitResult)
+	}
+
+	result := &mty.MultiSigResult{
+		CreateAddr:     res.CreateAddr,
+		MultiSigAddr:   res.MultiSigAddr,
+		Owners:         res.Owners,
+		DailyLimits:    dailyLimitResults,
+		TxCount:        res.TxCount,
+		RequiredWeight: res.RequiredWeight,
+	}
+
+	return result, nil
+}
+
+//GetMultiSigAccTxCountCmd 获取多重签名账户上的tx交易数量
+func GetMultiSigAccTxCountCmd() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "count",
+		Short: "get multisig tx count",
+		Run:   getMultiSigAccTxCount,
+	}
+	getMultiSigAccTxCountFlags(cmd)
+	return cmd
+}
+
+func getMultiSigAccTxCountFlags(cmd *cobra.Command) {
+	cmd.Flags().StringP("addr", "a", "", "address of multisig account")
+	cmd.MarkFlagRequired("addr")
+}
+
+func getMultiSigAccTxCount(cmd *cobra.Command, args []string) {
+	rpcLaddr, _ := cmd.Flags().GetString("rpc_laddr")
+	addr, _ := cmd.Flags().GetString("addr")
+
+	req := mty.ReqMultiSigAccInfo{
+		MultiSigAccAddr: addr,
+	}
+
+	var params rpctypes.Query4Jrpc
+	var rep interface{}
+
+	params.Execer = mty.MultiSigX
+	params.FuncName = "MultiSigAccTxCount"
+	params.Payload = types.MustPBToJSON(&req)
+	rep = &mty.Uint64{}
+	ctx := jsonclient.NewRPCCtx(rpcLaddr, "Chain33.Query", params, rep)
+	ctx.Run()
+}
+
+//GetMultiSigTxidsCmd 获取多重签名账户上的tx交易数量
+func GetMultiSigTxidsCmd() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "txids",
+		Short: "get multisig txids",
+		Run:   getMultiSigTxids,
+	}
+	getMultiSigTxidsCmdFlags(cmd)
+	return cmd
+}
+
+func getMultiSigTxidsCmdFlags(cmd *cobra.Command) {
+	cmd.Flags().StringP("addr", "a", "", "address of multisig account")
+	cmd.MarkFlagRequired("addr")
+
+	cmd.Flags().Uint64P("start", "s", 0, "tx start index")
+	cmd.MarkFlagRequired("start")
+
+	cmd.Flags().Uint64P("end", "e", 0, "tx end index")
+	cmd.MarkFlagRequired("end")
+
+	cmd.Flags().StringP("pending", "p", "t", "whether pending tx (0/f/false for No; 1/t/true for Yes)")
+
+	cmd.Flags().StringP("executed", "x", "t", "whether executed tx (0/f/false for No; 1/t/true for Yes)")
+
+}
+
+func getMultiSigTxids(cmd *cobra.Command, args []string) {
+	rpcLaddr, _ := cmd.Flags().GetString("rpc_laddr")
+	addr, _ := cmd.Flags().GetString("addr")
+
+	start, _ := cmd.Flags().GetUint64("start")
+	end, _ := cmd.Flags().GetUint64("end")
+	if start > end || start < 0 {
+		fmt.Fprintln(os.Stderr, "input parameter invalid!")
+		return
+	}
+
+	pending, _ := cmd.Flags().GetString("pending")
+	pendingBool, err := strconv.ParseBool(pending)
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		return
+	}
+
+	executed, _ := cmd.Flags().GetString("executed")
+	executedBool, err := strconv.ParseBool(executed)
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		return
+	}
+
+	req := mty.ReqMultiSigTxids{
+		MultiSigAddr: addr,
+		FromTxId:     start,
+		ToTxId:       end,
+		Pending:      pendingBool,
+		Executed:     executedBool,
+	}
+
+	var params rpctypes.Query4Jrpc
+	var rep interface{}
+
+	params.Execer = mty.MultiSigX
+	params.FuncName = "MultiSigTxids"
+	params.Payload = types.MustPBToJSON(&req)
+	rep = &mty.ReplyMultiSigTxids{}
+	ctx := jsonclient.NewRPCCtx(rpcLaddr, "Chain33.Query", params, rep)
+	ctx.Run()
+}
+
+//GetMultiSigTxInfoCmd 获取已经创建的多重签名账户的交易信息
+func GetMultiSigTxInfoCmd() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "info",
+		Short: "get multisig account tx info",
+		Run:   getMultiSigTxInfo,
+	}
+	getMultiSigTxInfoFlags(cmd)
+	return cmd
+}
+
+func getMultiSigTxInfoFlags(cmd *cobra.Command) {
+	cmd.Flags().StringP("addr", "a", "", "address of multisig account")
+	cmd.MarkFlagRequired("addr")
+
+	cmd.Flags().Uint64P("txid", "i", 0, "txid of  multisig transaction")
+	cmd.MarkFlagRequired("txid")
+}
+
+func getMultiSigTxInfo(cmd *cobra.Command, args []string) {
+	rpcLaddr, _ := cmd.Flags().GetString("rpc_laddr")
+	addr, _ := cmd.Flags().GetString("addr")
+	txid, _ := cmd.Flags().GetUint64("txid")
+
+	req := mty.ReqMultiSigTxInfo{
+		MultiSigAddr: addr,
+		TxId:         txid,
+	}
+
+	var params rpctypes.Query4Jrpc
+	var rep interface{}
+
+	params.Execer = mty.MultiSigX
+	params.FuncName = "MultiSigTxInfo"
+	params.Payload = types.MustPBToJSON(&req)
+	rep = &mty.MultiSigTx{}
+	ctx := jsonclient.NewRPCCtx(rpcLaddr, "Chain33.Query", params, rep)
+	ctx.Run()
+}
+
+//GetMultiSigTxConfirmedWeightCmd 获取交易已经被确认的总权重
+func GetMultiSigTxConfirmedWeightCmd() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "confirmed_weight",
+		Short: "get the weight of the transaction confirmed.",
+		Run:   getGetMultiSigTxConfirmedWeight,
+	}
+	getMultiSigTxConfirmedWeightFlags(cmd)
+	return cmd
+}
+
+func getMultiSigTxConfirmedWeightFlags(cmd *cobra.Command) {
+	cmd.Flags().StringP("addr", "a", "", "address of multisig account")
+	cmd.MarkFlagRequired("addr")
+
+	cmd.Flags().Uint64P("txid", "i", 0, "txid of  multisig transaction")
+	cmd.MarkFlagRequired("txid")
+}
+
+func getGetMultiSigTxConfirmedWeight(cmd *cobra.Command, args []string) {
+	rpcLaddr, _ := cmd.Flags().GetString("rpc_laddr")
+	addr, _ := cmd.Flags().GetString("addr")
+	txid, _ := cmd.Flags().GetUint64("txid")
+
+	req := mty.ReqMultiSigTxInfo{
+		MultiSigAddr: addr,
+		TxId:         txid,
+	}
+
+	var params rpctypes.Query4Jrpc
+	var rep interface{}
+
+	params.Execer = mty.MultiSigX
+	params.FuncName = "MultiSigTxConfirmedWeight"
+	params.Payload = types.MustPBToJSON(&req)
+	rep = &mty.Uint64{}
+	ctx := jsonclient.NewRPCCtx(rpcLaddr, "Chain33.Query", params, rep)
+	ctx.Run()
+}
+
+//GetMultiSigAccUnSpentTodayCmd 获取多重签名账户今日免多重签名的余额
+func GetMultiSigAccUnSpentTodayCmd() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "unspent",
+		Short: "get assets unspent today amount",
+		Run:   getMultiSigAccUnSpentToday,
+	}
+	getMultiSigAccUnSpentTodayFlags(cmd)
+	return cmd
+}
+
+func getMultiSigAccUnSpentTodayFlags(cmd *cobra.Command) {
+	cmd.Flags().StringP("addr", "a", "", "address of multisig account")
+	cmd.MarkFlagRequired("addr")
+
+	cmd.Flags().StringP("execer", "e", "", "assets execer name")
+	cmd.Flags().StringP("symbol", "s", "", "assets symbol")
+}
+
+func getMultiSigAccUnSpentToday(cmd *cobra.Command, args []string) {
+	rpcLaddr, _ := cmd.Flags().GetString("rpc_laddr")
+	addr, _ := cmd.Flags().GetString("addr")
+	execer, _ := cmd.Flags().GetString("execer")
+	symbol, _ := cmd.Flags().GetString("symbol")
+
+	isallBool := true
+	assets := &mty.Assets{}
+	//获取指定资产信息时，execer和symbol不能为空
+	if len(execer) != 0 && len(symbol) != 0 {
+		err := mty.IsAssetsInvalid(execer, symbol)
+		if err != nil {
+			fmt.Fprintln(os.Stderr, err)
+			return
+		}
+		assets.Execer = execer
+		assets.Symbol = symbol
+		isallBool = false
+	}
+
+	req := mty.ReqAccAssets{
+		MultiSigAddr: addr,
+		Assets:       assets,
+		IsAll:        isallBool,
+	}
+
+	var params rpctypes.Query4Jrpc
+	var rep interface{}
+
+	params.Execer = mty.MultiSigX
+	params.FuncName = "MultiSigAccUnSpentToday"
+	params.Payload = types.MustPBToJSON(&req)
+	rep = &mty.ReplyUnSpentAssets{}
+	ctx := jsonclient.NewRPCCtx(rpcLaddr, "Chain33.Query", params, rep)
+	ctx.SetResultCb(parseUnSpentToday)
+	ctx.Run()
+}
+
+func parseUnSpentToday(view interface{}) (interface{}, error) {
+	res := view.(*mty.ReplyUnSpentAssets)
+	var result []*mty.UnSpentAssetsResult
+
+	for _, unSpentAssets := range res.UnSpentAssets {
+		amountResult := strconv.FormatFloat(float64(unSpentAssets.Amount)/float64(types.Coin), 'f', 4, 64)
+		unSpentAssetsResult := &mty.UnSpentAssetsResult{
+			Execer:  unSpentAssets.Assets.Execer,
+			Symbol:  unSpentAssets.Assets.Symbol,
+			UnSpent: amountResult,
+		}
+		result = append(result, unSpentAssetsResult)
+	}
+	return result, nil
+}
+
+//GetMultiSigAccAssetsCmd 获取多重签名账户上的资产信息
+func GetMultiSigAccAssetsCmd() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "assets",
+		Short: "get assets of multisig account",
+		Run:   getMultiSigAccAssets,
+	}
+	getMultiSigAccAssetsFlags(cmd)
+	return cmd
+}
+
+func getMultiSigAccAssetsFlags(cmd *cobra.Command) {
+	cmd.Flags().StringP("addr", "a", "", "address of multisig account")
+	cmd.MarkFlagRequired("addr")
+
+	cmd.Flags().StringP("execer", "e", "coins", "assets execer name ")
+	cmd.Flags().StringP("symbol", "s", "BTY", "assets symbol")
+}
+
+func getMultiSigAccAssets(cmd *cobra.Command, args []string) {
+	rpcLaddr, _ := cmd.Flags().GetString("rpc_laddr")
+	addr, _ := cmd.Flags().GetString("addr")
+	execer, _ := cmd.Flags().GetString("execer")
+	symbol, _ := cmd.Flags().GetString("symbol")
+
+	isallBool := true
+	assets := &mty.Assets{}
+	//获取指定资产信息时，execer和symbol不能为空
+	if len(execer) != 0 && len(symbol) != 0 {
+		err := mty.IsAssetsInvalid(execer, symbol)
+		if err != nil {
+			fmt.Fprintln(os.Stderr, err)
+			return
+		}
+		assets.Execer = execer
+		assets.Symbol = symbol
+		isallBool = false
+	}
+
+	req := mty.ReqAccAssets{
+		MultiSigAddr: addr,
+		Assets:       assets,
+		IsAll:        isallBool,
+	}
+
+	var params rpctypes.Query4Jrpc
+	var rep interface{}
+
+	params.Execer = mty.MultiSigX
+	params.FuncName = "MultiSigAccAssets"
+	params.Payload = types.MustPBToJSON(&req)
+	rep = &mty.ReplyAccAssets{}
+	ctx := jsonclient.NewRPCCtx(rpcLaddr, "Chain33.Query", params, rep)
+	ctx.SetResultCb(parseAccAssets)
+	ctx.Run()
+}
+
+func parseAccAssets(view interface{}) (interface{}, error) {
+	res := view.(*mty.ReplyAccAssets)
+	var result []*mty.AccAssetsResult
+
+	for _, accAssets := range res.AccAssets {
+		balanceResult := strconv.FormatFloat(float64(accAssets.Account.Balance)/float64(types.Coin), 'f', 4, 64)
+		frozenResult := strconv.FormatFloat(float64(accAssets.Account.Frozen)/float64(types.Coin), 'f', 4, 64)
+		receiverResult := strconv.FormatFloat(float64(accAssets.RecvAmount)/float64(types.Coin), 'f', 4, 64)
+
+		accAssetsResult := &mty.AccAssetsResult{
+			Execer:   accAssets.Assets.Execer,
+			Symbol:   accAssets.Assets.Symbol,
+			Addr:     accAssets.Account.Addr,
+			Currency: accAssets.Account.Currency,
+			Balance:  balanceResult,
+			Frozen:   frozenResult,
+			Receiver: receiverResult,
+		}
+		result = append(result, accAssetsResult)
+	}
+	return result, nil
+}
+
+//GetMultiSigAccAllAddressCmd 获取指定地址创建的所有多重签名账户
+func GetMultiSigAccAllAddressCmd() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "creator",
+		Short: "get all multisig accounts created by the address",
+		Run:   getMultiSigAccAllAddress,
+	}
+	getMultiSigAccAllAddressFlags(cmd)
+	return cmd
+}
+
+func getMultiSigAccAllAddressFlags(cmd *cobra.Command) {
+	cmd.Flags().StringP("addr", "a", "", "address of created multisig account")
+	cmd.MarkFlagRequired("addr")
+}
+
+func getMultiSigAccAllAddress(cmd *cobra.Command, args []string) {
+	rpcLaddr, _ := cmd.Flags().GetString("rpc_laddr")
+	createAddr, _ := cmd.Flags().GetString("addr")
+
+	var params rpctypes.Query4Jrpc
+	var rep interface{}
+	req := mty.ReqMultiSigAccInfo{
+		MultiSigAccAddr: createAddr,
+	}
+	params.Execer = mty.MultiSigX
+	params.FuncName = "MultiSigAccAllAddress"
+	params.Payload = types.MustPBToJSON(&req)
+	rep = &mty.AccAddress{}
+	ctx := jsonclient.NewRPCCtx(rpcLaddr, "Chain33.Query", params, rep)
+	ctx.Run()
+}
+
+func isValidDailylimit(dailylimit float64) error {
+	if dailylimit < 0 || float64(types.MaxCoin/types.Coin) < dailylimit {
+		return mty.ErrInvalidDailyLimit
+	}
+	return nil
+}

plugin/dapp/multisig/doc.go

+// Copyright Fuzamei Corp. 2018 All Rights Reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package multisig
+
+/*
+多重签名合约实现功能：
+创建一个多重签名的账户，并指定owner已经权重
+账户属性交易：
+	owner的add/del/modify/replace
+	资产每日限额的修改
+	请求权重的修改
+账户属性的修改都是一个交易，需要满足权重的要求才能被执行。
+
+账户交易的确认和撤销：当交易提交者的权重不能满足权重要求时，需要其余的owner来一起确认。owner可以撤销自己对某笔交易的确认，但此交易必须是没有被执行。已执行的不应许撤销
+
+多重签名账户的转入和转出：转入时，to地址必须是多重签名地址，from地址必须是非多重签名地址；
+					 转出时，from地址必须是多重签名地址，to地址必须是非多重签名地址； 传出交易需要校验权重
+
+cli 命令行主要分三块：account 账户相关的，owner 相关的以及tx交易相关的
+cli multisig
+Available Commands:
+  account     multisig account
+  owner       multisig owner
+  tx          multisig tx
+
+cli multisig  account
+Available Commands:
+  address     get multisig account address
+  assets      get assets of multisig account
+  count       get multisig account count
+  create      Create a multisig account transaction
+  creator     get all multisig accounts created by the address
+  dailylimit  Create a modify assets dailylimit transaction
+  info        get multisig account info
+  unspent     get assets unspent today amount
+  weight      Create a modify required weight transaction
+
+cli multisig  owner
+Available Commands:
+  add         Create a add owner  transaction
+  del         Create a del owner transaction
+  modify      Create a modify owner weight transaction
+  replace     Create a replace owner transaction
+
+cli multisig  tx
+Available Commands:
+  confirm          Create a confirm transaction
+  confirmed_weight get the weight of the transaction confirmed.
+  count            get multisig tx count
+  info             get multisig account tx info
+  transfer_in      Create a transfer to multisig account transaction
+  transfer_out     Create a transfer from multisig account transaction
+  txids            get multisig txids
+
+
+测试步骤如下：
+cli seed save -p heyubin -s "voice leisure mechanic tape cluster grunt receive joke nurse between monkey lunch save useful cruise"
+
+cli wallet unlock -p heyubin
+
+cli account import_key  -l miner -k CC38546E9E659D15E6B4893F0AB32A06D103931A8230B0BDE71459D2B27D6944
+
+cli account create -l heyubin
+cli account create -l heyubin1
+cli account create -l heyubin2
+cli account create -l heyubin3
+cli account create -l heyubin4
+cli account create -l heyubin5
+cli account create -l heyubin6
+cli account create -l heyubin7
+cli account create -l heyubin8
+
+
+cli send bty transfer -a 100 -n test  -t 1DkrXbz2bK6XMpY4v9z2YUnhwWTXT6V5jd -k 14KEKbYtKKQm4wMthSK9J4La4nAiidGozt
+cli send bty transfer -a 100 -n test  -t 1Kkgztjcni3xKw95y2VZHwPpsSHDEH5sXF -k 14KEKbYtKKQm4wMthSK9J4La4nAiidGozt
+cli send bty transfer -a 100 -n test  -t 1N8LP5gBufZXCEdf3hyViDhWFqeB7WPGdv -k 14KEKbYtKKQm4wMthSK9J4La4nAiidGozt
+cli send bty transfer -a 100 -n test  -t 1C5xK2ytuoFqxmVGMcyz9XFKFWcDA8T3rK -k 14KEKbYtKKQm4wMthSK9J4La4nAiidGozt
+
+cli send bty transfer -a 100 -n test  -t "1LDGrokrZjo1HtSmSnw8ef3oy5Vm1nctbj" -k 14KEKbYtKKQm4wMthSK9J4La4nAiidGozt
+cli send bty transfer -a 100 -n test  -t "17a5NQTf9M2Dz9qBS8KiQ8VUg8qhoYeQbA" -k 14KEKbYtKKQm4wMthSK9J4La4nAiidGozt
+cli send bty transfer -a 100 -n test  -t "1DeGvSFX8HAFsuHxhaVkLX56Ke3FzFbdct" -k 14KEKbYtKKQm4wMthSK9J4La4nAiidGozt
+cli send bty transfer -a 100 -n test  -t "166po3ghRbRu53hu8jBBQzddp7kUJ9Ynyf" -k 14KEKbYtKKQm4wMthSK9J4La4nAiidGozt
+cli send bty transfer -a 100 -n test  -t "1KHwX7ZadNeQDjBGpnweb4k2dqj2CWtAYo" -k 14KEKbYtKKQm4wMthSK9J4La4nAiidGozt
+
+
+
+第一步：1DkrXbz2bK6XMpY4v9z2YUnhwWTXT6V5jd地址创建多重签名的账户，owner：1Kkgztjcni3xKw95y2VZHwPpsSHDEH5sXF  1N8LP5gBufZXCEdf3hyViDhWFqeB7WPGdv
+//构建交易
+cli send multisig account create -d 10 -e coins -s BTY -a "1C5xK2ytuoFqxmVGMcyz9XFKFWcDA8T3rK 1LDGrokrZjo1HtSmSnw8ef3oy5Vm1nctbj" -w "20 10" -r 15 -k 1DkrXbz2bK6XMpY4v9z2YUnhwWTXT6V5jd
+
+//查看创建的账户个数
+cli multisig account count
+
+//通过账户index获取账户地址
+cli multisig account address -e 0 -s 0
+
+//通过账户addr获取账户详情
+cli multisig account info -a "13q53Ga1kquDCqx7EWF8FU94tLUK18Zd47"
+
+
+第二步，向multisig合约中转账 1DkrXbz2bK6XMpY4v9z2YUnhwWTXT6V5jd
+
+cli exec addr -e "multisig"
+14uBEP6LSHKdFvy97pTYRPVPAqij6bteee
+
+// 转账
+cli send bty transfer -a 50 -n test  -t 14uBEP6LSHKdFvy97pTYRPVPAqij6bteee -k 1DkrXbz2bK6XMpY4v9z2YUnhwWTXT6V5jd
+
+cli account balance -a 1DkrXbz2bK6XMpY4v9z2YUnhwWTXT6V5jd
+
+
+第三步：从指定账户转账到多重签名地址 1DkrXbz2bK6XMpY4v9z2YUnhwWTXT6V5jd   --》 "13q53Ga1kquDCqx7EWF8FU94tLUK18Zd47"
+
+cli send multisig tx transfer_in -a 40 -e coins -s BTY  -t "13q53Ga1kquDCqx7EWF8FU94tLUK18Zd47" -n test -k 1DkrXbz2bK6XMpY4v9z2YUnhwWTXT6V5jd
+
+
+//查看1DkrXbz2bK6XMpY4v9z2YUnhwWTXT6V5jd地上有40被转出了
+cli account balance -a 1DkrXbz2bK6XMpY4v9z2YUnhwWTXT6V5jd
+
+
+//多重签名地址转入40并冻结
+cli account balance -a "13q53Ga1kquDCqx7EWF8FU94tLUK18Zd47"
+
+cli multisig  account assets  -a "13q53Ga1kquDCqx7EWF8FU94tLUK18Zd47"
+
+
+第四步：从多重签名账户传出  "13q53Ga1kquDCqx7EWF8FU94tLUK18Zd47"  --》1LDGrokrZjo1HtSmSnw8ef3oy5Vm1nctbj  owner:1C5xK2ytuoFqxmVGMcyz9XFKFWcDA8T3rK签名
+cli send multisig  tx transfer_out  -a 11 -e coins -s BTY -f "13q53Ga1kquDCqx7EWF8FU94tLUK18Zd47" -t 1LDGrokrZjo1HtSmSnw8ef3oy5Vm1nctbj -n test -k "1C5xK2ytuoFqxmVGMcyz9XFKFWcDA8T3rK"
+
+
+查询账户信息
+cli multisig account info -a "13q53Ga1kquDCqx7EWF8FU94tLUK18Zd47"
+
+cli multisig  account assets  -a "13q53Ga1kquDCqx7EWF8FU94tLUK18Zd47"
+
+查询接受地址是否收到币
+cli multisig  account assets  -a 1LDGrokrZjo1HtSmSnw8ef3oy5Vm1nctbj
+
+
+// 查询交易计数
+cli multisig  tx count  -a "13q53Ga1kquDCqx7EWF8FU94tLUK18Zd47"
+
+// 查询交易txid
+cli multisig   tx txids  -a "13q53Ga1kquDCqx7EWF8FU94tLUK18Zd47" -s 0 -e 0
+
+// 查询交易信息
+cli multisig  tx info  -a "13q53Ga1kquDCqx7EWF8FU94tLUK18Zd47" -i 0
+
+
+//owner "1LDGrokrZjo1HtSmSnw8ef3oy5Vm1nctbj," 转账5个币到1LDGrokrZjo1HtSmSnw8ef3oy5Vm1nctbj    owner:1LDGrokrZjo1HtSmSnw8ef3oy5Vm1nctbj签名
+cli send multisig  tx transfer_out  -a 5 -e coins -s BTY -f "13q53Ga1kquDCqx7EWF8FU94tLUK18Zd47" -t 1LDGrokrZjo1HtSmSnw8ef3oy5Vm1nctbj -n test -k "1LDGrokrZjo1HtSmSnw8ef3oy5Vm1nctbj"
+
+
+第五步：测试add/del owner  使用高权重的owner添加交易 "1C5xK2ytuoFqxmVGMcyz9XFKFWcDA8T3rK",  add 1KHwX7ZadNeQDjBGpnweb4k2dqj2CWtAYo
+
+cli send multisig owner add  -a "13q53Ga1kquDCqx7EWF8FU94tLUK18Zd47" -o 1KHwX7ZadNeQDjBGpnweb4k2dqj2CWtAYo -w 5 -k  "1C5xK2ytuoFqxmVGMcyz9XFKFWcDA8T3rK"
+
+
+查看owner的添加
+cli multisig  account info -a 13q53Ga1kquDCqx7EWF8FU94tLUK18Zd47
+
+cli multisig  tx info  -a "13q53Ga1kquDCqx7EWF8FU94tLUK18Zd47" -i 0
+
+//del owner
+cli send multisig  owner del  -a "13q53Ga1kquDCqx7EWF8FU94tLUK18Zd47" -o "1KHwX7ZadNeQDjBGpnweb4k2dqj2CWtAYo"  -k 1C5xK2ytuoFqxmVGMcyz9XFKFWcDA8T3rK
+// modify  dailylimit
+cli send multisig  account dailylimit -a "13q53Ga1kquDCqx7EWF8FU94tLUK18Zd47" -e coins -s BTY -d 12 -k 1C5xK2ytuoFqxmVGMcyz9XFKFWcDA8T3rK
+// modify weight
+cli send multisig  account weight -a "13q53Ga1kquDCqx7EWF8FU94tLUK18Zd47" -w 16 -k 1C5xK2ytuoFqxmVGMcyz9XFKFWcDA8T3rK
+//replace owner
+cli send multisig  owner replace  -a "13q53Ga1kquDCqx7EWF8FU94tLUK18Zd47" -n 166po3ghRbRu53hu8jBBQzddp7kUJ9Ynyf -o 1LDGrokrZjo1HtSmSnw8ef3oy5Vm1nctbj -k  1C5xK2ytuoFqxmVGMcyz9XFKFWcDA8T3rK
+// modify owner
+cli send multisig  owner modify  -a "13q53Ga1kquDCqx7EWF8FU94tLUK18Zd47" -o "166po3ghRbRu53hu8jBBQzddp7kUJ9Ynyf" -w 11 -k 1C5xK2ytuoFqxmVGMcyz9XFKFWcDA8T3rK
+
+//获取指定地址创建的所有多重签名账户
+cli multisig account creator -a 1DkrXbz2bK6XMpY4v9z2YUnhwWTXT6V5jd
+
+// 获取指定账户上指定资产的每日余额
+cli multisig  account unspent  -a 13q53Ga1kquDCqx7EWF8FU94tLUK18Zd47 -e coins -s BTY
+
+第五步：测试交易的确认和撤销
+//权重低的转账，owner：166po3ghRbRu53hu8jBBQzddp7kUJ9Ynyf
+cli send multisig  tx transfer_out  -a 10 -e coins -s BTY -f "13q53Ga1kquDCqx7EWF8FU94tLUK18Zd47" -t 1LDGrokrZjo1HtSmSnw8ef3oy5Vm1nctbj -n test -k "166po3ghRbRu53hu8jBBQzddp7kUJ9Ynyf"
+
+
+//撤销对某笔交易的确认
+cli send   multisig tx confirm  -a "13q53Ga1kquDCqx7EWF8FU94tLUK18Zd47" -i 8 -c f  -k 166po3ghRbRu53hu8jBBQzddp7kUJ9Ynyf
+
+
+//确认某笔交易
+cli send multisig tx confirm  -a "13q53Ga1kquDCqx7EWF8FU94tLUK18Zd47" -i 8 -k "166po3ghRbRu53hu8jBBQzddp7kUJ9Ynyf"
+
+cli send multisig tx confirm  -a "13q53Ga1kquDCqx7EWF8FU94tLUK18Zd47" -i 8 -k "1C5xK2ytuoFqxmVGMcyz9XFKFWcDA8T3rK"
+
+*/

plugin/dapp/multisig/executor/action.go

+// Copyright Fuzamei Corp. 2018 All Rights Reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package executor
+
+import (
+	"encoding/hex"
+
+	"github.com/33cn/chain33/account"
+	"github.com/33cn/chain33/client"
+	"github.com/33cn/chain33/common/address"
+	dbm "github.com/33cn/chain33/common/db"
+	"github.com/33cn/chain33/system/dapp"
+	"github.com/33cn/chain33/types"
+	mty "github.com/33cn/plugin/plugin/dapp/multisig/types"
+)
+
+//action 结构体
+type action struct {
+	coinsAccount *account.DB
+	db           dbm.KV
+	localdb      dbm.KVDB
+	txhash       []byte
+	fromaddr     string
+	blocktime    int64
+	height       int64
+	index        int32
+	execaddr     string
+	api          client.QueueProtocolAPI
+}
+
+func newAction(t *MultiSig, tx *types.Transaction, index int32) *action {
+	hash := tx.Hash()
+	fromaddr := tx.From()
+	return &action{t.GetCoinsAccount(), t.GetStateDB(), t.GetLocalDB(), hash, fromaddr,
+		t.GetBlockTime(), t.GetHeight(), index, dapp.ExecAddress(string(tx.Execer)), t.GetAPI()}
+}
+
+//MultiSigAccCreate 创建多重签名账户
+func (a *action) MultiSigAccCreate(accountCreate *mty.MultiSigAccCreate) (*types.Receipt, error) {
+	var logs []*types.ReceiptLog
+	var kv []*types.KeyValue
+	var totalweight uint64
+	var ownerCount int
+	var dailyLimit mty.DailyLimit
+
+	//参数校验
+	if accountCreate == nil {
+		return nil, types.ErrInvalidParam
+	}
+	//创建时requiredweight权重的值不能大于所有owner权重之和
+	for _, owner := range accountCreate.Owners {
+		if owner != nil {
+			totalweight += owner.Weight
+			ownerCount = ownerCount + 1
+		}
+	}
+
+	if accountCreate.RequiredWeight > totalweight {
+		return nil, mty.ErrRequiredweight
+	}
+
+	//创建时最少设置两个owner
+	if ownerCount < mty.MinOwnersInit {
+		return nil, mty.ErrOwnerLessThanTwo
+	}
+	//owner总数不能大于最大值
+	if ownerCount > mty.MaxOwnersCount {
+		return nil, mty.ErrMaxOwnerCount
+	}
+
+	multiSigAccount := &mty.MultiSig{}
+	multiSigAccount.CreateAddr = a.fromaddr
+	multiSigAccount.Owners = accountCreate.Owners
+	multiSigAccount.TxCount = 0
+	multiSigAccount.RequiredWeight = accountCreate.RequiredWeight
+
+	//获取资产的每日限额设置
+	if accountCreate.DailyLimit != nil {
+		symbol := accountCreate.DailyLimit.Symbol
+		execer := accountCreate.DailyLimit.Execer
+		err := mty.IsAssetsInvalid(execer, symbol)
+		if err != nil {
+			return nil, err
+		}
+		dailyLimit.Symbol = symbol
+		dailyLimit.Execer = execer
+		dailyLimit.DailyLimit = accountCreate.DailyLimit.DailyLimit
+		dailyLimit.SpentToday = 0
+		dailyLimit.LastDay = a.blocktime //types.Now().Unix()
+		multiSigAccount.DailyLimits = append(multiSigAccount.DailyLimits, &dailyLimit)
+	}
+	//通过创建交易的txhash生成一个唯一的多重签名合约 NewAddrFromString
+	addr := address.MultiSignAddress(a.txhash)
+	//账户去重校验
+	multiSig, err := getMultiSigAccount(a.localdb, addr)
+	if err == nil && multiSig != nil {
+		return nil, mty.ErrAccountHasExist
+	}
+
+	multiSigAccount.MultiSigAddr = addr
+	receiptLog := &types.ReceiptLog{}
+	receiptLog.Ty = mty.TyLogMultiSigAccCreate
+	receiptLog.Log = types.Encode(multiSigAccount)
+	logs = append(logs, receiptLog)
+
+	key, value := setMultiSigAccToDb(a.db, multiSigAccount)
+	kv = append(kv, &types.KeyValue{Key: key, Value: value})
+
+	return &types.Receipt{Ty: types.ExecOk, KV: kv, Logs: logs}, nil
+}
+
+//MultiSigAccOperate 多重签名账户属性的修改：weight权重以及每日限额的修改
+//修改requiredweight权重值不能大于当前所有owner权重之和
+func (a *action) MultiSigAccOperate(AccountOperate *mty.MultiSigAccOperate) (*types.Receipt, error) {
+
+	if AccountOperate == nil {
+		return nil, types.ErrInvalidParam
+	}
+	//首先从statedb中获取MultiSigAccAddr的状态信息
+	multiSigAccAddr := AccountOperate.MultiSigAccAddr
+	multiSigAccount, err := getMultiSigAccFromDb(a.db, multiSigAccAddr)
+	if err != nil {
+		multisiglog.Error("MultiSigAccountOperate", "MultiSigAccAddr", multiSigAccAddr, "err", err)
+		return nil, err
+	}
+
+	if multiSigAccount == nil {
+		multisiglog.Error("MultiSigAccountOperate:getMultiSigAccFromDb is nil", "MultiSigAccAddr", multiSigAccAddr)
+		return nil, types.ErrAccountNotExist
+	}
+
+	//校验交易提交者是否是本账户的owner
+	owneraddr := a.fromaddr
+	ownerWeight, isowner := isOwner(multiSigAccount, owneraddr)
+	if !isowner {
+		return nil, mty.ErrIsNotOwner
+	}
+
+	//dailylimit每日限额属性的修改需要校验assets资产的合法性
+	if !AccountOperate.OperateFlag {
+		execer := AccountOperate.DailyLimit.Execer
+		symbol := AccountOperate.DailyLimit.Symbol
+		err := mty.IsAssetsInvalid(execer, symbol)
+		if err != nil {
+			return nil, err
+		}
+	}
+	//生成新的txid,并将此交易信息添加到Txs列表中
+	txID := multiSigAccount.TxCount
+	newMultiSigTx := &mty.MultiSigTx{}
+	newMultiSigTx.Txid = txID
+	newMultiSigTx.TxHash = hex.EncodeToString(a.txhash)
+	newMultiSigTx.Executed = false
+	newMultiSigTx.TxType = mty.AccountOperate
+	newMultiSigTx.MultiSigAddr = multiSigAccAddr
+	confirmOwner := &mty.Owner{OwnerAddr: owneraddr, Weight: ownerWeight}
+	newMultiSigTx.ConfirmedOwner = append(newMultiSigTx.ConfirmedOwner, confirmOwner)
+
+	return a.executeAccOperateTx(multiSigAccount, newMultiSigTx, AccountOperate, confirmOwner, true)
+}
+
+//MultiSigOwnerOperate 多重签名账户owner属性的修改：owner的add/del/replace等
+//在del和replace owner时需要保证修改后所有owner的权重之和大于requiredweight值
+func (a *action) MultiSigOwnerOperate(AccOwnerOperate *mty.MultiSigOwnerOperate) (*types.Receipt, error) {
+	multiSigAccAddr := AccOwnerOperate.MultiSigAccAddr
+
+	//首先从statedb中获取MultiSigAccAddr的状态信息
+	multiSigAccount, err := getMultiSigAccFromDb(a.db, multiSigAccAddr)
+	if err != nil {
+		multisiglog.Error("MultiSigAccountOperate", "MultiSigAccAddr", multiSigAccAddr, "err", err)
+		return nil, err
+	}
+	if multiSigAccount == nil {
+		multisiglog.Error("MultiSigAccountOwnerOperate:getMultiSigAccFromDb is nil", "MultiSigAccAddr", multiSigAccAddr)
+		return nil, types.ErrAccountNotExist
+	}
+
+	//校验交易提交者是否是本账户的owner
+	owneraddr := a.fromaddr
+	ownerWeight, isowner := isOwner(multiSigAccount, owneraddr)
+	if !isowner {
+		return nil, mty.ErrIsNotOwner
+	}
+
+	//生成新的txid,并将此交易信息添加到Txs列表中
+	txID := multiSigAccount.TxCount
+	newMultiSigTx := &mty.MultiSigTx{}
+	newMultiSigTx.Txid = txID
+	newMultiSigTx.TxHash = hex.EncodeToString(a.txhash)
+	newMultiSigTx.Executed = false
+	newMultiSigTx.TxType = mty.OwnerOperate
+	newMultiSigTx.MultiSigAddr = multiSigAccAddr
+	confirmOwner := &mty.Owner{OwnerAddr: owneraddr, Weight: ownerWeight}
+	newMultiSigTx.ConfirmedOwner = append(newMultiSigTx.ConfirmedOwner, confirmOwner)
+
+	return a.executeOwnerOperateTx(multiSigAccount, newMultiSigTx, AccOwnerOperate, confirmOwner, true)
+}
+
+//MultiSigExecTransferFrom 首先判断转账的额度是否大于每日限量，小于就直接执行交易，调用ExecTransferFrozen进行转账
+//大于每日限量只需要将交易信息记录
+//合约中多重签名账户转账到外部账户，multiSigAddr--->Addr
+func (a *action) MultiSigExecTransferFrom(multiSigAccTransfer *mty.MultiSigExecTransferFrom) (*types.Receipt, error) {
+
+	//首先从statedb中获取MultiSigAccAddr的状态信息
+	multiSigAccAddr := multiSigAccTransfer.From
+	multiSigAcc, err := getMultiSigAccFromDb(a.db, multiSigAccAddr)
+	if err != nil {
+		multisiglog.Error("MultiSigAccExecTransfer", "MultiSigAccAddr", multiSigAccAddr, "err", err)
+		return nil, err
+	}
+
+	// to 地址必须不是多重签名账户地址
+	multiSigAccTo, _ := getMultiSigAccFromDb(a.db, multiSigAccTransfer.To)
+	if multiSigAccTo != nil {
+		multisiglog.Error("MultiSigExecTransferFrom", "multiSigAccTo", multiSigAccTo, "ToAddr", multiSigAccTransfer.To)
+		return nil, mty.ErrAddrNotSupport
+	}
+
+	//校验交易提交者是否是本账户的owner
+	owneraddr := a.fromaddr
+	ownerWeight, isowner := isOwner(multiSigAcc, owneraddr)
+	if !isowner {
+		return nil, mty.ErrIsNotOwner
+	}
+
+	//assete资产合法性校验
+	err = mty.IsAssetsInvalid(multiSigAccTransfer.Execname, multiSigAccTransfer.Symbol)
+	if err != nil {
+		return nil, err
+	}
+	//生成新的txid,并将此交易信息添加到Txs列表中
+	txID := multiSigAcc.TxCount
+	newMultiSigTx := &mty.MultiSigTx{}
+	newMultiSigTx.Txid = txID
+	newMultiSigTx.TxHash = hex.EncodeToString(a.txhash)
+	newMultiSigTx.Executed = false
+	newMultiSigTx.TxType = mty.TransferOperate
+	newMultiSigTx.MultiSigAddr = multiSigAccAddr
+	confirmOwner := &mty.Owner{OwnerAddr: owneraddr, Weight: ownerWeight}
+	newMultiSigTx.ConfirmedOwner = append(newMultiSigTx.ConfirmedOwner, confirmOwner)
+
+	//确认并执行此交易
+	return a.executeTransferTx(multiSigAcc, newMultiSigTx, multiSigAccTransfer, confirmOwner, mty.IsSubmit)
+}
+
+//MultiSigExecTransferTo 将合约中外部账户转账上的Execname.Symbol资产转到多重签名账户上，from:Addr --->to:multiSigAddr
+// from地址使用tx中的签名的地址，payload中from地址不使用在 TransferTo交易中
+func (a *action) MultiSigExecTransferTo(execTransfer *mty.MultiSigExecTransferTo) (*types.Receipt, error) {
+
+	//from地址校验必须不是多重签名账户地址
+	multiSigAccFrom, _ := getMultiSigAccFromDb(a.db, a.fromaddr)
+	if multiSigAccFrom != nil {
+		multisiglog.Error("MultiSigExecTransferTo", "multiSigAccFrom", multiSigAccFrom, "From", a.fromaddr)
+		return nil, mty.ErrAddrNotSupport
+	}
+	// to 地址必须是多重签名账户地址
+	multiSigAccTo, _ := getMultiSigAccFromDb(a.db, execTransfer.To)
+	if multiSigAccTo == nil {
+		multisiglog.Error("MultiSigExecTransferTo", "ToAddr", execTransfer.To)
+		return nil, mty.ErrAddrNotSupport
+	}
+	//assete资产合法性校验
+	err := mty.IsAssetsInvalid(execTransfer.Execname, execTransfer.Symbol)
+	if err != nil {
+		return nil, err
+	}
+
+	//将指定账户上的资产从balance转账到多重签名账户的balance上
+	symbol := getRealSymbol(execTransfer.Symbol)
+	newAccountDB, err := account.NewAccountDB(execTransfer.Execname, symbol, a.db)
+	if err != nil {
+		return nil, err
+	}
+	receiptExecTransfer, err := newAccountDB.ExecTransfer(a.fromaddr, execTransfer.To, a.execaddr, execTransfer.Amount)
+	if err != nil {
+		multisiglog.Error("MultiSigExecTransfer:ExecTransfer", "From", a.fromaddr,
+			"To", execTransfer.To, "execaddr", a.execaddr,
+			"amount", execTransfer.Amount, "Execer", execTransfer.Execname, "Symbol", execTransfer.Symbol, "error", err)
+		return nil, err
+	}
+	//将多重签名账户上的balance冻结起来
+	receiptExecFrozen, err := newAccountDB.ExecFrozen(execTransfer.To, a.execaddr, execTransfer.Amount)
+	if err != nil {
+		multisiglog.Error("MultiSigExecTransfer:ExecFrozen", "addr", execTransfer.To, "execaddr", a.execaddr,
+			"amount", execTransfer.Amount, "Execer", execTransfer.Execname, "Symbol", execTransfer.Symbol, "error", err)
+		return nil, err
+	}
+
+	var logs []*types.ReceiptLog
+	var kv []*types.KeyValue
+
+	logs = append(logs, receiptExecTransfer.Logs...)
+	logs = append(logs, receiptExecFrozen.Logs...)
+	kv = append(kv, receiptExecTransfer.KV...)
+	kv = append(kv, receiptExecFrozen.KV...)
+	return &types.Receipt{Ty: types.ExecOk, KV: kv, Logs: logs}, nil
+}
+
+//MultiSigConfirmTx 多重签名账户上MultiSigAcc账户Transfer交易的确认和撤销
+//确认交易需要判断权重是否满足，满足就直接执行交易，调用ExecTransferFrozen进行转账
+//不满足就只更新本交易的确认owner
+//撤销确认交易，只允许撤销还没有被执行的交易，只更新本交易的确认owner
+func (a *action) MultiSigConfirmTx(ConfirmTx *mty.MultiSigConfirmTx) (*types.Receipt, error) {
+
+	//首先从statedb中获取MultiSigAccAddr的状态信息
+	multiSigAccAddr := ConfirmTx.MultiSigAccAddr
+	multiSigAcc, err := getMultiSigAccFromDb(a.db, multiSigAccAddr)
+	if err != nil {
+		multisiglog.Error("MultiSigConfirmTx:getMultiSigAccFromDb", "MultiSigAccAddr", multiSigAccAddr, "err", err)
+		return nil, err
+	}
+	//校验交易提交者是否是本账户的owner
+	owneraddr := a.fromaddr
+	ownerWeight, isowner := isOwner(multiSigAcc, owneraddr)
+	if !isowner {
+		multisiglog.Error("MultiSigConfirmTx: is not Owner", "MultiSigAccAddr", multiSigAccAddr, "txFrom", owneraddr, "err", err)
+		return nil, mty.ErrIsNotOwner
+	}
+	//TxId的合法性校验
+	if ConfirmTx.TxId > multiSigAcc.TxCount {
+		multisiglog.Error("MultiSigConfirmTx: Invalid Txid", "MultiSigAccTxCount", multiSigAcc.TxCount, "Confirm TxId", ConfirmTx.TxId, "err", err)
+		return nil, mty.ErrInvalidTxid
+	}
+	//获取多重签名账户上txid对应的交易信息
+	multiSigTx, err := getMultiSigAccTxFromDb(a.db, multiSigAccAddr, ConfirmTx.TxId)
+	if err != nil {
+		multisiglog.Error("MultiSigConfirmTx:getMultiSigAccTxFromDb", "multiSigAccAddr", multiSigAccAddr, "Confirm TxId", ConfirmTx.TxId, "err", err)
+		return nil, mty.ErrTxidNotExist
+	}
+	//已经被执行的交易不可以再确认/撤销
+	if multiSigTx.Executed {
+		return nil, mty.ErrTxHasExecuted
+	}
+	//此owneraddr是否已经确认过此txid对应的交易
+	findindex, exist := isOwnerConfirmedTx(multiSigTx, owneraddr)
+
+	//不能重复确认同一笔交易直接返回
+	if exist && ConfirmTx.ConfirmOrRevoke {
+		return nil, mty.ErrDupConfirmed
+	}
+	//需要撤销的确认信息没有找到直接返回
+	if !exist && !ConfirmTx.ConfirmOrRevoke {
+		return nil, mty.ErrConfirmNotExist
+	}
+
+	owner := &mty.Owner{OwnerAddr: owneraddr, Weight: ownerWeight}
+
+	//首先处理撤销确认交易，将owneraddr的确认信息从交易确认列表中删除
+	if exist && !ConfirmTx.ConfirmOrRevoke {
+		multiSigTx.ConfirmedOwner = append(multiSigTx.ConfirmedOwner[0:findindex], multiSigTx.ConfirmedOwner[findindex+1:]...)
+	} else if !exist && ConfirmTx.ConfirmOrRevoke {
+		//增加此owner的确认信息到multiSigTx的确认列表中
+		multiSigTx.ConfirmedOwner = append(multiSigTx.ConfirmedOwner, owner)
+	}
+
+	multiSigTxOwner := &mty.MultiSigTxOwner{MultiSigAddr: multiSigAccAddr, Txid: ConfirmTx.TxId, ConfirmedOwner: owner}
+	isConfirm := isConfirmed(multiSigAcc.RequiredWeight, multiSigTx)
+
+	//权重未达到要求或者撤销确认交易，构造MultiSigConfirmTx的receiptLog
+	if !isConfirm || !ConfirmTx.ConfirmOrRevoke {
+		return a.confirmTransaction(multiSigTx, multiSigTxOwner, ConfirmTx.ConfirmOrRevoke)
+	}
+	//获取txhash对应交易详细信息
+	tx, err := getTxByHash(a.api, multiSigTx.TxHash)
+	if err != nil {
+		return nil, err
+	}
+	payload, err := getMultiSigTxPayload(tx)
+	if err != nil {
+		return nil, err
+	}
+
+	//根据不同的交易类型调用各自的处理函数，区分 操作owner/account 和转账的交易
+	if multiSigTx.TxType == mty.OwnerOperate && payload != nil {
+		transfer := payload.GetMultiSigOwnerOperate()
+		return a.executeOwnerOperateTx(multiSigAcc, multiSigTx, transfer, owner, false)
+	} else if multiSigTx.TxType == mty.AccountOperate {
+		transfer := payload.GetMultiSigAccOperate()
+		return a.executeAccOperateTx(multiSigAcc, multiSigTx, transfer, owner, false)
+	} else if multiSigTx.TxType == mty.TransferOperate {
+		transfer := payload.GetMultiSigExecTransferFrom()
+		return a.executeTransferTx(multiSigAcc, multiSigTx, transfer, owner, mty.IsConfirm)
+	}
+	multisiglog.Error("MultiSigConfirmTx:GetMultiSigTx", "multiSigAccAddr", multiSigAccAddr, "Confirm TxId", ConfirmTx.TxId, "TxType unknown", multiSigTx.TxType)
+	return nil, mty.ErrTxTypeNoMatch
+}
+
+//多重签名账户请求权重的修改,返回新的KeyValue对和ReceiptLog信息
+func (a *action) multiSigWeightModify(multiSigAccAddr string, newRequiredWeight uint64) (*types.KeyValue, *types.ReceiptLog, error) {
+
+	multiSigAccount, err := getMultiSigAccFromDb(a.db, multiSigAccAddr)
+	if err != nil {
+		multisiglog.Error("multiSigWeightModify", "MultiSigAccAddr", multiSigAccAddr, "err", err)
+		return nil, nil, err
+	}
+
+	if multiSigAccount == nil {
+		multisiglog.Error("multiSigWeightModify:getMultiSigAccFromDb is nil", "MultiSigAccAddr", multiSigAccAddr)
+		return nil, nil, types.ErrAccountNotExist
+	}
+
+	//首先获取所有owner的权重之和，新设置的newRequiredWeight不能大于owner的权重之和
+	var totalweight uint64
+	receiptLog := &types.ReceiptLog{}
+	for _, owner := range multiSigAccount.Owners {
+		if owner != nil {
+			totalweight += owner.Weight
+		}
+	}
+	if newRequiredWeight > totalweight {
+		return nil, nil, mty.ErrRequiredweight
+	}
+	//修改RequiredWeight字段
+	prevWeight := multiSigAccount.RequiredWeight
+	multiSigAccount.RequiredWeight = newRequiredWeight
+
+	//组装receiptLog
+	receiptWeight := &mty.ReceiptWeightModify{}
+	receiptWeight.MultiSigAddr = multiSigAccount.MultiSigAddr
+	receiptWeight.PrevWeight = prevWeight
+	receiptWeight.CurrentWeight = multiSigAccount.RequiredWeight
+	receiptLog.Ty = mty.TyLogMultiSigAccWeightModify
+	receiptLog.Log = types.Encode(receiptWeight)
+
+	key, value := setMultiSigAccToDb(a.db, multiSigAccount)
+	kv := &types.KeyValue{Key: key, Value: value}
+	return kv, receiptLog, nil
+}
+
+//多重签名账户资产每日限额的添加或者修改,
+func (a *action) multiSigDailyLimitOperate(multiSigAccAddr string, dailylimit *mty.SymbolDailyLimit) (*types.KeyValue, *types.ReceiptLog, error) {
+
+	multiSigAccount, err := getMultiSigAccFromDb(a.db, multiSigAccAddr)
+	if err != nil {
+		multisiglog.Error("multiSigDailyLimitOperate", "MultiSigAccAddr", multiSigAccAddr, "err", err)
+		return nil, nil, err
+	}
+
+	if multiSigAccount == nil {
+		multisiglog.Error("multiSigDailyLimitOperate:getMultiSigAccFromDb is nil", "MultiSigAccAddr", multiSigAccAddr)
+		return nil, nil, types.ErrAccountNotExist
+	}
+
+	flag := false
+	var addOrModify bool
+	var findindex int
+	var curDailyLimit *mty.DailyLimit
+
+	receiptLog := &types.ReceiptLog{}
+
+	newSymbol := dailylimit.Symbol
+	newExecer := dailylimit.Execer
+	newDailyLimit := dailylimit.DailyLimit
+
+	prevDailyLimit := &mty.DailyLimit{Symbol: newSymbol, Execer: newExecer, DailyLimit: 0, SpentToday: 0, LastDay: 0}
+	//首先遍历获取需要修改的symbol每日限额,没有找到就添加
+	for index, dailyLimit := range multiSigAccount.DailyLimits {
+		if dailyLimit.Symbol == newSymbol && dailyLimit.Execer == newExecer {
+			prevDailyLimit.DailyLimit = dailyLimit.DailyLimit
+			prevDailyLimit.SpentToday = dailyLimit.SpentToday
+			prevDailyLimit.LastDay = dailyLimit.LastDay
+			flag = true
+			findindex = index
+			break
+		}
+	}
+	if flag { //modify old DailyLimit
+		multiSigAccount.DailyLimits[findindex].DailyLimit = newDailyLimit
+		curDailyLimit = multiSigAccount.DailyLimits[findindex]
+		addOrModify = false
+	} else { //add new DailyLimit
+		temDailyLimit := &mty.DailyLimit{}
+		temDailyLimit.Symbol = newSymbol
+		temDailyLimit.Execer = newExecer
+		temDailyLimit.DailyLimit = newDailyLimit
+		temDailyLimit.SpentToday = 0
+		temDailyLimit.LastDay = a.blocktime //types.Now().Unix()
+		multiSigAccount.DailyLimits = append(multiSigAccount.DailyLimits, temDailyLimit)
+
+		curDailyLimit = temDailyLimit
+		addOrModify = true
+	}
+	receiptDailyLimit := &mty.ReceiptDailyLimitOperate{
+		MultiSigAddr:   multiSigAccount.MultiSigAddr,
+		PrevDailyLimit: prevDailyLimit,
+		CurDailyLimit:  curDailyLimit,
+		AddOrModify:    addOrModify,
+	}
+	receiptLog.Ty = mty.TyLogMultiSigAccDailyLimitModify
+	receiptLog.Log = types.Encode(receiptDailyLimit)
+
+	key, value := setMultiSigAccToDb(a.db, multiSigAccount)
+	kv := &types.KeyValue{Key: key, Value: value}
+	return kv, receiptLog, nil
+}
+
+//多重签名账户的添加,返回新的KeyValue对和ReceiptLog信息
+func (a *action) multiSigOwnerAdd(multiSigAccAddr string, AccOwnerOperate *mty.MultiSigOwnerOperate) (*types.KeyValue, *types.ReceiptLog, error) {
+
+	//添加newowner到账户的owner中
+	var newOwner mty.Owner
+	newOwner.OwnerAddr = AccOwnerOperate.NewOwner
+	newOwner.Weight = AccOwnerOperate.NewWeight
+	return a.receiptOwnerAddOrDel(multiSigAccAddr, &newOwner, true)
+}
+
+//多重签名账户的删除,返回新的KeyValue对和ReceiptLog信息
+func (a *action) multiSigOwnerDel(multiSigAccAddr string, AccOwnerOperate *mty.MultiSigOwnerOperate) (*types.KeyValue, *types.ReceiptLog, error) {
+	var owner mty.Owner
+	owner.OwnerAddr = AccOwnerOperate.OldOwner
+	owner.Weight = 0
+	return a.receiptOwnerAddOrDel(multiSigAccAddr, &owner, false)
+}
+
+//组装add/del owner的receipt信息
+func (a *action) receiptOwnerAddOrDel(multiSigAccAddr string, owner *mty.Owner, addOrDel bool) (*types.KeyValue, *types.ReceiptLog, error) {
+	receiptLog := &types.ReceiptLog{}
+
+	multiSigAcc, err := getMultiSigAccFromDb(a.db, multiSigAccAddr)
+	if err != nil {
+		multisiglog.Error("receiptOwnerAddOrDel", "MultiSigAccAddr", multiSigAccAddr, "err", err)
+		return nil, nil, err
+	}
+
+	if multiSigAcc == nil {
+		multisiglog.Error("receiptOwnerAddOrDel:getMultiSigAccFromDb is nil", "MultiSigAccAddr", multiSigAccAddr)
+		return nil, nil, types.ErrAccountNotExist
+	}
+
+	oldweight, index, totalWeight, totalowner, exist := getOwnerInfoByAddr(multiSigAcc, owner.OwnerAddr)
+
+	if addOrDel {
+		if exist {
+			return nil, nil, mty.ErrOwnerExist
+		}
+		if totalowner >= mty.MaxOwnersCount {
+			return nil, nil, mty.ErrMaxOwnerCount
+		}
+		multiSigAcc.Owners = append(multiSigAcc.Owners, owner)
+		receiptLog.Ty = mty.TyLogMultiSigOwnerAdd
+	} else {
+		if !exist {
+			return nil, nil, mty.ErrOwnerNotExist
+		}
+		//删除时需要确认删除后所有owners的权重之和必须大于reqweight
+		if totalWeight-oldweight < multiSigAcc.RequiredWeight {
+			return nil, nil, mty.ErrTotalWeightNotEnough
+		}
+		//最少要保留一个owner
+		if totalowner <= 1 {
+			return nil, nil, mty.ErrOnlyOneOwner
+		}
+		owner.Weight = oldweight
+		receiptLog.Ty = mty.TyLogMultiSigOwnerDel
+		multiSigAcc.Owners = delOwner(multiSigAcc.Owners, index)
+	}
+
+	//组装receiptLog
+	receiptOwner := &mty.ReceiptOwnerAddOrDel{}
+	receiptOwner.MultiSigAddr = multiSigAcc.MultiSigAddr
+	receiptOwner.Owner = owner
+	receiptOwner.AddOrDel = addOrDel
+	receiptLog.Log = types.Encode(receiptOwner)
+
+	key, value := setMultiSigAccToDb(a.db, multiSigAcc)
+	keyValue := &types.KeyValue{Key: key, Value: value}
+	return keyValue, receiptLog, nil
+}
+
+//多重签名账户owner的修改,返回新的KeyValue对和ReceiptLog信息
+func (a *action) multiSigOwnerModify(multiSigAccAddr string, AccOwnerOperate *mty.MultiSigOwnerOperate) (*types.KeyValue, *types.ReceiptLog, error) {
+
+	prev := &mty.Owner{OwnerAddr: AccOwnerOperate.OldOwner, Weight: 0}
+	cur := &mty.Owner{OwnerAddr: AccOwnerOperate.OldOwner, Weight: AccOwnerOperate.NewWeight}
+	return a.receiptOwnerModOrRep(multiSigAccAddr, prev, cur, true)
+}
+
+//多重签名账户owner的替换,返回新的KeyValue对和ReceiptLog信息
+func (a *action) multiSigOwnerReplace(multiSigAccAddr string, AccOwnerOperate *mty.MultiSigOwnerOperate) (*types.KeyValue, *types.ReceiptLog, error) {
+
+	prev := &mty.Owner{OwnerAddr: AccOwnerOperate.OldOwner, Weight: 0}
+	cur := &mty.Owner{OwnerAddr: AccOwnerOperate.NewOwner, Weight: 0}
+	return a.receiptOwnerModOrRep(multiSigAccAddr, prev, cur, false)
+}
+
+//组装修改/替换owner的receipt信息
+func (a *action) receiptOwnerModOrRep(multiSigAccAddr string, prev *mty.Owner, cur *mty.Owner, modOrRep bool) (*types.KeyValue, *types.ReceiptLog, error) {
+	receiptLog := &types.ReceiptLog{}
+
+	multiSigAcc, err := getMultiSigAccFromDb(a.db, multiSigAccAddr)
+	if err != nil {
+		multisiglog.Error("receiptOwnerModOrRep", "MultiSigAccAddr", multiSigAccAddr, "err", err)
+		return nil, nil, err
+	}
+
+	if multiSigAcc == nil {
+		multisiglog.Error("receiptOwnerModOrRep:getMultiSigAccFromDb is nil", "MultiSigAccAddr", multiSigAccAddr)
+		return nil, nil, types.ErrAccountNotExist
+	}
+	oldweight, index, totalWeight, _, exist := getOwnerInfoByAddr(multiSigAcc, prev.OwnerAddr)
+	if modOrRep {
+		if !exist {
+			return nil, nil, mty.ErrOwnerNotExist
+		}
+		//修改时需要确认修改后所有owners的权重之和必须大于reqweight
+		if totalWeight-oldweight+cur.Weight < multiSigAcc.RequiredWeight {
+			return nil, nil, mty.ErrTotalWeightNotEnough
+		}
+		prev.Weight = oldweight
+		multiSigAcc.Owners[index].Weight = cur.Weight
+		receiptLog.Ty = mty.TyLogMultiSigOwnerModify
+	} else {
+		if !exist {
+			return nil, nil, mty.ErrOwnerNotExist
+		}
+		//替换时newowner应该不存在
+		_, _, _, _, find := getOwnerInfoByAddr(multiSigAcc, cur.OwnerAddr)
+		if find {
+			return nil, nil, mty.ErrNewOwnerExist
+		}
+		prev.Weight = oldweight
+		cur.Weight = oldweight
+		multiSigAcc.Owners[index].OwnerAddr = cur.OwnerAddr
+		receiptLog.Ty = mty.TyLogMultiSigOwnerReplace
+	}
+	//组装receiptLog
+	receiptAddOwner := &mty.ReceiptOwnerModOrRep{}
+	receiptAddOwner.MultiSigAddr = multiSigAcc.MultiSigAddr
+	receiptAddOwner.PrevOwner = prev
+	receiptAddOwner.CurrentOwner = cur
+	receiptAddOwner.ModOrRep = modOrRep
+	receiptLog.Log = types.Encode(receiptAddOwner)
+
+	key, value := setMultiSigAccToDb(a.db, multiSigAcc)
+	keyValue := &types.KeyValue{Key: key, Value: value}
+	return keyValue, receiptLog, nil
+}
+
+//组装AccExecTransfer的receipt信息,需要区分是在提交交易时执行的，还是在确认阶段执行的交易
+func (a *action) receiptDailyLimitUpdate(multiSigAccAddr string, findindex int, curdailyLimit *mty.DailyLimit) (*types.KeyValue, *types.ReceiptLog, error) {
+
+	multiSigAcc, err := getMultiSigAccFromDb(a.db, multiSigAccAddr)
+	if err != nil {
+		multisiglog.Error("receiptDailyLimitUpdate", "MultiSigAccAddr", multiSigAccAddr, "err", err)
+		return nil, nil, err
+	}
+
+	if multiSigAcc == nil {
+		multisiglog.Error("receiptDailyLimitUpdate:getMultiSigAccFromDb is nil", "MultiSigAccAddr", multiSigAccAddr)
+		return nil, nil, types.ErrAccountNotExist
+	}
+	receiptLog := &types.ReceiptLog{}
+
+	//组装receiptLog
+	receipt := &mty.ReceiptAccDailyLimitUpdate{}
+	receipt.MultiSigAddr = multiSigAcc.MultiSigAddr
+	receipt.PrevDailyLimit = multiSigAcc.DailyLimits[findindex]
+	receipt.CurDailyLimit = curdailyLimit
+	receiptLog.Ty = mty.TyLogDailyLimitUpdate
+	receiptLog.Log = types.Encode(receipt)
+
+	//更新DailyLimit
+	multiSigAcc.DailyLimits[findindex].SpentToday = curdailyLimit.SpentToday
+	multiSigAcc.DailyLimits[findindex].LastDay = curdailyLimit.LastDay
+
+	key, value := setMultiSigAccToDb(a.db, multiSigAcc)
+	keyValue := &types.KeyValue{Key: key, Value: value}
+	return keyValue, receiptLog, nil
+}
+
+//组装修改账户属性时交易计数的增加和的receipt信息
+func (a *action) receiptTxCountUpdate(multiSigAccAddr string) (*types.KeyValue, *types.ReceiptLog, error) {
+
+	multiSigAcc, err := getMultiSigAccFromDb(a.db, multiSigAccAddr)
+	if err != nil {
+		multisiglog.Error("receiptTxCountUpdate", "MultiSigAccAddr", multiSigAccAddr, "err", err)
+		return nil, nil, err
+	}
+
+	if multiSigAcc == nil {
+		multisiglog.Error("receiptTxCountUpdate:getMultiSigAccFromDb is nil", "MultiSigAccAddr", multiSigAccAddr)
+		return nil, nil, types.ErrAccountNotExist
+	}
+
+	receiptLog := &types.ReceiptLog{}
+
+	//组装receiptLog
+	multiSigAcc.TxCount++
+
+	receiptLogTxCount := &mty.ReceiptTxCountUpdate{
+		MultiSigAddr: multiSigAcc.MultiSigAddr,
+		CurTxCount:   multiSigAcc.TxCount,
+	}
+
+	receiptLog.Ty = mty.TyLogTxCountUpdate
+	receiptLog.Log = types.Encode(receiptLogTxCount)
+
+	key, value := setMultiSigAccToDb(a.db, multiSigAcc)
+	keyValue := &types.KeyValue{Key: key, Value: value}
+	return keyValue, receiptLog, nil
+}
+
+//组装MultiSigAccTx的receipt信息
+func (a *action) receiptMultiSigTx(multiSigTx *mty.MultiSigTx, owner *mty.Owner, prevExecutes, subOrConfirm bool) (*types.KeyValue, *types.ReceiptLog) {
+	receiptLog := &types.ReceiptLog{}
+
+	//组装receiptLog
+	receiptLogTx := &mty.ReceiptMultiSigTx{}
+	multiSigTxOwner := &mty.MultiSigTxOwner{MultiSigAddr: multiSigTx.MultiSigAddr, Txid: multiSigTx.Txid, ConfirmedOwner: owner}
+
+	receiptLogTx.MultiSigTxOwner = multiSigTxOwner
+	receiptLogTx.PrevExecuted = prevExecutes
+	receiptLogTx.CurExecuted = multiSigTx.Executed
+	receiptLogTx.SubmitOrConfirm = subOrConfirm
+	if subOrConfirm {
+		receiptLogTx.TxHash = multiSigTx.TxHash
+		receiptLogTx.TxType = multiSigTx.TxType
+	}
+
+	receiptLog.Ty = mty.TyLogMultiSigTx
+	receiptLog.Log = types.Encode(receiptLogTx)
+
+	key, value := setMultiSigAccTxToDb(a.db, multiSigTx)
+	keyValue := &types.KeyValue{Key: key, Value: value}
+	return keyValue, receiptLog
+}
+
+//确认并执行转账交易：区分submitTx和confirmtx阶段。
+func (a *action) executeTransferTx(multiSigAcc *mty.MultiSig, newMultiSigTx *mty.MultiSigTx, transfer *mty.MultiSigExecTransferFrom, confOwner *mty.Owner, subOrConfirm bool) (*types.Receipt, error) {
+
+	//获取对应资产的每日限额信息
+	var findindex int
+	curDailyLimit := &mty.DailyLimit{Symbol: transfer.Symbol, Execer: transfer.Execname, DailyLimit: 0, SpentToday: 0, LastDay: 0}
+	for Index, dailyLimit := range multiSigAcc.DailyLimits {
+		if dailyLimit.Symbol == transfer.Symbol && dailyLimit.Execer == transfer.Execname {
+			curDailyLimit.DailyLimit = dailyLimit.DailyLimit
+			curDailyLimit.SpentToday = dailyLimit.SpentToday
+			curDailyLimit.LastDay = dailyLimit.LastDay
+			findindex = Index
+			break
+		}
+	}
+	//每日限额为0不允许转账
+	if curDailyLimit.DailyLimit == 0 {
+		return nil, mty.ErrDailyLimitIsZero
+	}
+
+	//确认此交易额度是否在每日限额之内，或者权重已达到要求
+	amount := transfer.Amount
+	confirmed := isConfirmed(multiSigAcc.RequiredWeight, newMultiSigTx)
+	underLimit, newlastday := isUnderLimit(a.blocktime, uint64(amount), curDailyLimit)
+
+	//新的一天更新lastday和spenttoday的值
+	if newlastday != 0 {
+		curDailyLimit.LastDay = newlastday
+		curDailyLimit.SpentToday = 0
+	}
+
+	prevExecuted := newMultiSigTx.Executed
+
+	var logs []*types.ReceiptLog
+	var kv []*types.KeyValue
+
+	//权重满足或者小于每日限额，允许执行此交易，如果转账交易执行失败，不应该直接返回，需要继续更新多重签名账户和tx列表的状态信息
+	if confirmed || underLimit {
+
+		//执行此交易，从多重签名账户转币到指定账户，在multiSig合约中转账
+		symbol := getRealSymbol(transfer.Symbol)
+		execerAccDB, err := account.NewAccountDB(transfer.Execname, symbol, a.db)
+		if err != nil {
+			multisiglog.Error("executeTransaction:NewAccountDB", "From", transfer.From, "To", transfer.To,
+				"execaddr", a.execaddr, "amount", amount, "Execer", transfer.Execname, "Symbol", transfer.Symbol, "error", err)
+			return nil, err
+		}
+		receiptFromMultiSigAcc, err := execerAccDB.ExecTransferFrozen(transfer.From, transfer.To, a.execaddr, amount)
+		if err != nil {
+			multisiglog.Error("executeTransaction:ExecTransferFrozen", "From", transfer.From, "To", transfer.To,
+				"execaddr", a.execaddr, "amount", amount, "Execer", transfer.Execname, "Symbol", transfer.Symbol, "error", err)
+			return nil, err
+		}
+		logs = append(logs, receiptFromMultiSigAcc.Logs...)
+		kv = append(kv, receiptFromMultiSigAcc.KV...)
+
+		//标识此交易已经被执行
+		newMultiSigTx.Executed = true
+
+		//增加今日已用金额, 只有在提交交易时才会使用每日限额的额度
+		if !confirmed && subOrConfirm {
+			curDailyLimit.SpentToday += uint64(amount)
+		}
+	}
+
+	//更新multiSigAcc状态:txcount有增加在submit阶段
+	if subOrConfirm {
+		keyvalue, receiptlog, err := a.receiptTxCountUpdate(multiSigAcc.MultiSigAddr)
+		if err != nil {
+			multisiglog.Error("executeTransaction:receiptTxCountUpdate", "error", err)
+		}
+		kv = append(kv, keyvalue)
+		logs = append(logs, receiptlog)
+	}
+
+	//更新multiSigAcc状态:对应资产的每日限额信息可能有更新
+	keyvalue, receiptlog, err := a.receiptDailyLimitUpdate(multiSigAcc.MultiSigAddr, findindex, curDailyLimit)
+	if err != nil {
+		multisiglog.Error("executeTransaction:receiptDailyLimitUpdate", "error", err)
+	}
+	//更新newMultiSigTx的状态：MultiSigTx增加一个确认owner，交易的执行状态可能有更新
+	keyvaluetx, receiptlogtx := a.receiptMultiSigTx(newMultiSigTx, confOwner, prevExecuted, subOrConfirm)
+
+	logs = append(logs, receiptlog)
+	logs = append(logs, receiptlogtx)
+	kv = append(kv, keyvalue)
+	kv = append(kv, keyvaluetx)
+
+	//test
+	multisiglog.Error("executeTransferTx", "multiSigAcc", multiSigAcc, "newMultiSigTx", newMultiSigTx)
+
+	return &types.Receipt{
+		Ty:   types.ExecOk,
+		KV:   kv,
+		Logs: logs,
+	}, nil
+}
+
+//确认并执行操作账户属性的交易：区分submitTx和confirmtx阶段。
+func (a *action) executeAccOperateTx(multiSigAcc *mty.MultiSig, newMultiSigTx *mty.MultiSigTx, accountOperate *mty.MultiSigAccOperate, confOwner *mty.Owner, subOrConfirm bool) (*types.Receipt, error) {
+
+	//确认权重是否已达到要求
+	confirmed := isConfirmed(multiSigAcc.RequiredWeight, newMultiSigTx)
+	prevExecuted := newMultiSigTx.Executed
+
+	var logs []*types.ReceiptLog
+	var kv []*types.KeyValue
+
+	var accAttrkv *types.KeyValue
+	var accAttrReceiptLog *types.ReceiptLog
+	var err error
+
+	//权重满足允许执行此交易，需要继续更新多重签名账户和tx列表的状态信息
+	if confirmed {
+		//修改账户RequiredWeight的操作
+		if accountOperate.OperateFlag {
+			accAttrkv, accAttrReceiptLog, err = a.multiSigWeightModify(multiSigAcc.MultiSigAddr, accountOperate.NewRequiredWeight)
+			if err != nil {
+				multisiglog.Error("executeAccOperateTx", "multiSigWeightModify", err)
+				return nil, err
+			}
+		} else { //资产每日限额的修改
+			accAttrkv, accAttrReceiptLog, err = a.multiSigDailyLimitOperate(multiSigAcc.MultiSigAddr, accountOperate.DailyLimit)
+			if err != nil {
+				multisiglog.Error("executeAccOperateTx", "multiSigDailyLimitOperate", err)
+				return nil, err
+			}
+		}
+		logs = append(logs, accAttrReceiptLog)
+		kv = append(kv, accAttrkv)
+		//标识此交易已经被执行
+		newMultiSigTx.Executed = true
+	}
+
+	//更新multiSigAcc状态:txcount有增加在submit阶段
+	if subOrConfirm {
+		keyvalue, receiptlog, err := a.receiptTxCountUpdate(multiSigAcc.MultiSigAddr)
+		if err != nil {
+			multisiglog.Error("executeAccOperateTx:receiptTxCountUpdate", "error", err)
+		}
+		kv = append(kv, keyvalue)
+		logs = append(logs, receiptlog)
+	}
+	//更新newMultiSigTx的状态：MultiSigTx增加一个确认owner，交易的执行状态可能有更新
+	keyvaluetx, receiptlogtx := a.receiptMultiSigTx(newMultiSigTx, confOwner, prevExecuted, subOrConfirm)
+	logs = append(logs, receiptlogtx)
+	kv = append(kv, keyvaluetx)
+	return &types.Receipt{
+		Ty:   types.ExecOk,
+		KV:   kv,
+		Logs: logs,
+	}, nil
+}
+
+//确认并执行操作owner属性的交易：区分submitTx和confirmtx阶段。
+func (a *action) executeOwnerOperateTx(multiSigAccount *mty.MultiSig, newMultiSigTx *mty.MultiSigTx, accountOperate *mty.MultiSigOwnerOperate, confOwner *mty.Owner, subOrConfirm bool) (*types.Receipt, error) {
+	var logs []*types.ReceiptLog
+	var kv []*types.KeyValue
+
+	var multiSigkv *types.KeyValue
+	var receiptLog *types.ReceiptLog
+	var err error
+	//确认权重是否已达到要求
+	confirmed := isConfirmed(multiSigAccount.RequiredWeight, newMultiSigTx)
+	prevExecuted := newMultiSigTx.Executed
+
+	flag := accountOperate.OperateFlag
+
+	//权重满足允许执行此交易，需要继续更新多重签名账户和tx列表的状态信息
+	if confirmed {
+		//add
+		if mty.OwnerAdd == flag {
+			multiSigkv, receiptLog, err = a.multiSigOwnerAdd(multiSigAccount.MultiSigAddr, accountOperate)
+			if err != nil {
+				multisiglog.Error("MultiSigAccountOwnerOperate", "multiSigOwnerAdd err", err)
+				return nil, err
+			}
+
+		} else if mty.OwnerDel == flag {
+			multiSigkv, receiptLog, err = a.multiSigOwnerDel(multiSigAccount.MultiSigAddr, accountOperate)
+			if err != nil {
+				multisiglog.Error("MultiSigAccountOwnerOperate", "multiSigOwnerAdd err", err)
+				return nil, err
+			}
+		} else if mty.OwnerModify == flag { //modify owner
+			multiSigkv, receiptLog, err = a.multiSigOwnerModify(multiSigAccount.MultiSigAddr, accountOperate)
+			if err != nil {
+				multisiglog.Error("MultiSigAccountOwnerOperate", "multiSigOwnerModify err", err)
+				return nil, err
+			}
+		} else if mty.OwnerReplace == flag { //replace owner
+			multiSigkv, receiptLog, err = a.multiSigOwnerReplace(multiSigAccount.MultiSigAddr, accountOperate)
+			if err != nil {
+				multisiglog.Error("MultiSigAccountOwnerOperate", "multiSigOwnerReplace err", err)
+				return nil, err
+			}
+		} else {
+			multisiglog.Error("MultiSigAccountOwnerOperate", "OperateFlag", flag)
+			return nil, mty.ErrOperateType
+		}
+		logs = append(logs, receiptLog)
+		kv = append(kv, multiSigkv)
+
+		//标识此交易已经被执行
+		newMultiSigTx.Executed = true
+	}
+
+	//更新multiSigAcc状态:txcount有增加在submit阶段
+	if subOrConfirm {
+		keyvalue, receiptlog, err := a.receiptTxCountUpdate(multiSigAccount.MultiSigAddr)
+		if err != nil {
+			multisiglog.Error("executeOwnerOperateTx:receiptTxCountUpdate", "error", err)
+		}
+		kv = append(kv, keyvalue)
+		logs = append(logs, receiptlog)
+	}
+	//更新newMultiSigTx的状态：MultiSigTx增加一个确认owner，交易的执行状态可能有更新
+	keyvaluetx, receiptlogtx := a.receiptMultiSigTx(newMultiSigTx, confOwner, prevExecuted, subOrConfirm)
+	logs = append(logs, receiptlogtx)
+	kv = append(kv, keyvaluetx)
+
+	//test
+	multisiglog.Error("executeOwnerOperateTx", "multiSigAccount", multiSigAccount, "newMultiSigTx", newMultiSigTx)
+
+	return &types.Receipt{
+		Ty:   types.ExecOk,
+		KV:   kv,
+		Logs: logs,
+	}, nil
+}
+
+//构造确认交易的receiptLog
+func (a *action) confirmTransaction(multiSigTx *mty.MultiSigTx, multiSigTxOwner *mty.MultiSigTxOwner, ConfirmOrRevoke bool) (*types.Receipt, error) {
+	receiptLog := &types.ReceiptLog{}
+
+	receiptLogUnConfirmTx := &mty.ReceiptConfirmTx{MultiSigTxOwner: multiSigTxOwner, ConfirmeOrRevoke: ConfirmOrRevoke}
+	if ConfirmOrRevoke {
+		receiptLog.Ty = mty.TyLogMultiSigConfirmTx
+	} else {
+		receiptLog.Ty = mty.TyLogMultiSigConfirmTxRevoke
+	}
+	receiptLog.Log = types.Encode(receiptLogUnConfirmTx)
+
+	//更新MultiSigAccTx
+	key, value := setMultiSigAccTxToDb(a.db, multiSigTx)
+	kv := &types.KeyValue{Key: key, Value: value}
+
+	return &types.Receipt{
+		Ty:   types.ExecOk,
+		KV:   []*types.KeyValue{kv},
+		Logs: []*types.ReceiptLog{receiptLog},
+	}, nil
+}

plugin/dapp/multisig/executor/exec.go

+// Copyright Fuzamei Corp. 2018 All Rights Reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package executor
+
+import (
+	"github.com/33cn/chain33/types"
+	mty "github.com/33cn/plugin/plugin/dapp/multisig/types"
+)
+
+//Exec_MultiSigAccCreate 创建多重签名账户
+func (m *MultiSig) Exec_MultiSigAccCreate(payload *mty.MultiSigAccCreate, tx *types.Transaction, index int) (*types.Receipt, error) {
+	action := newAction(m, tx, int32(index))
+	return action.MultiSigAccCreate(payload)
+}
+
+//Exec_MultiSigOwnerOperate 多重签名账户owner属性的修改：owner的add/del/replace等
+func (m *MultiSig) Exec_MultiSigOwnerOperate(payload *mty.MultiSigOwnerOperate, tx *types.Transaction, index int) (*types.Receipt, error) {
+	action := newAction(m, tx, int32(index))
+	return action.MultiSigOwnerOperate(payload)
+}
+
+//Exec_MultiSigAccOperate 多重签名账户属性的修改：weight权重以及每日限额的修改
+func (m *MultiSig) Exec_MultiSigAccOperate(payload *mty.MultiSigAccOperate, tx *types.Transaction, index int) (*types.Receipt, error) {
+	action := newAction(m, tx, int32(index))
+	return action.MultiSigAccOperate(payload)
+}
+
+//Exec_MultiSigConfirmTx 多重签名账户上交易的确认和撤销
+func (m *MultiSig) Exec_MultiSigConfirmTx(payload *mty.MultiSigConfirmTx, tx *types.Transaction, index int) (*types.Receipt, error) {
+	action := newAction(m, tx, int32(index))
+	return action.MultiSigConfirmTx(payload)
+}
+
+//Exec_MultiSigExecTransferTo 合约中外部账户转账到多重签名账户，Addr --->multiSigAddr
+func (m *MultiSig) Exec_MultiSigExecTransferTo(payload *mty.MultiSigExecTransferTo, tx *types.Transaction, index int) (*types.Receipt, error) {
+	action := newAction(m, tx, int32(index))
+	return action.MultiSigExecTransferTo(payload)
+}
+
+//Exec_MultiSigExecTransferFrom 合约中多重签名账户转账到外部账户，multiSigAddr--->Addr
+func (m *MultiSig) Exec_MultiSigExecTransferFrom(payload *mty.MultiSigExecTransferFrom, tx *types.Transaction, index int) (*types.Receipt, error) {
+	action := newAction(m, tx, int32(index))
+	return action.MultiSigExecTransferFrom(payload)
+}

plugin/dapp/multisig/executor/exec_del_local.go

+// Copyright Fuzamei Corp. 2018 All Rights Reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package executor
+
+import (
+	"github.com/33cn/chain33/types"
+	mty "github.com/33cn/plugin/plugin/dapp/multisig/types"
+)
+
+//ExecDelLocal_MultiSigAccCreate 创建多重签名账户,根据payload和receiptData信息获取相关信息并保存到db中
+func (m *MultiSig) ExecDelLocal_MultiSigAccCreate(payload *mty.MultiSigAccCreate, tx *types.Transaction, receiptData *types.ReceiptData, index int) (*types.LocalDBSet, error) {
+	if receiptData.GetTy() != types.ExecOk {
+		return &types.LocalDBSet{}, nil
+	}
+
+	kv, err := m.execLocalMultiSigReceipt(receiptData, tx, false)
+	if err != nil {
+		return nil, err
+	}
+	return &types.LocalDBSet{KV: kv}, nil
+}
+
+//ExecDelLocal_MultiSigOwnerOperate 多重签名账户owner属性的修改：owner的add/del/replace/modify等
+func (m *MultiSig) ExecDelLocal_MultiSigOwnerOperate(payload *mty.MultiSigOwnerOperate, tx *types.Transaction, receiptData *types.ReceiptData, index int) (*types.LocalDBSet, error) {
+	if receiptData.GetTy() != types.ExecOk {
+		return &types.LocalDBSet{}, nil
+	}
+
+	kv, err := m.execLocalMultiSigReceipt(receiptData, tx, false)
+	if err != nil {
+		return nil, err
+	}
+	return &types.LocalDBSet{KV: kv}, nil
+}
+
+//ExecDelLocal_MultiSigAccOperate 多重签名账户属性的修改：weight权重以及每日限额的修改
+func (m *MultiSig) ExecDelLocal_MultiSigAccOperate(payload *mty.MultiSigAccOperate, tx *types.Transaction, receiptData *types.ReceiptData, index int) (*types.LocalDBSet, error) {
+	if receiptData.GetTy() != types.ExecOk {
+		return &types.LocalDBSet{}, nil
+	}
+
+	kv, err := m.execLocalMultiSigReceipt(receiptData, tx, false)
+	if err != nil {
+		return nil, err
+	}
+	return &types.LocalDBSet{KV: kv}, nil
+}
+
+//ExecDelLocal_MultiSigConfirmTx 多重签名账户上交易的确认和撤销
+func (m *MultiSig) ExecDelLocal_MultiSigConfirmTx(payload *mty.MultiSigConfirmTx, tx *types.Transaction, receiptData *types.ReceiptData, index int) (*types.LocalDBSet, error) {
+	if receiptData.GetTy() != types.ExecOk {
+		return &types.LocalDBSet{}, nil
+	}
+
+	kv, err := m.execLocalMultiSigReceipt(receiptData, tx, false)
+	if err != nil {
+		return nil, err
+	}
+	return &types.LocalDBSet{KV: kv}, nil
+}
+
+//ExecDelLocal_MultiSigExecTransferTo 合约中外部账户转账到多重签名账户，Addr --->multiSigAddr
+func (m *MultiSig) ExecDelLocal_MultiSigExecTransferTo(payload *mty.MultiSigExecTransferTo, tx *types.Transaction, receiptData *types.ReceiptData, index int) (*types.LocalDBSet, error) {
+	if receiptData.GetTy() != types.ExecOk {
+		return &types.LocalDBSet{}, nil
+	}
+
+	kv, err := m.saveMultiSigTransfer(tx, mty.IsSubmit, false)
+	if err != nil {
+		return nil, err
+	}
+	return &types.LocalDBSet{KV: kv}, nil
+}
+
+//ExecDelLocal_MultiSigExecTransferFrom 合约中多重签名账户转账到外部账户，multiSigAddr--->Addr
+func (m *MultiSig) ExecDelLocal_MultiSigExecTransferFrom(payload *mty.MultiSigExecTransferFrom, tx *types.Transaction, receiptData *types.ReceiptData, index int) (*types.LocalDBSet, error) {
+	if receiptData.GetTy() != types.ExecOk {
+		return &types.LocalDBSet{}, nil
+	}
+
+	kv, err := m.execLocalMultiSigReceipt(receiptData, tx, false)
+	if err != nil {
+		return nil, err
+	}
+	return &types.LocalDBSet{KV: kv}, nil
+}

plugin/dapp/multisig/executor/exec_local.go

+// Copyright Fuzamei Corp. 2018 All Rights Reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package executor
+
+import (
+	"github.com/33cn/chain33/types"
+	mty "github.com/33cn/plugin/plugin/dapp/multisig/types"
+)
+
+//ExecLocal_MultiSigAccCreate 创建多重签名账户,根据payload和receiptData信息获取相关信息并保存到db中
+func (m *MultiSig) ExecLocal_MultiSigAccCreate(payload *mty.MultiSigAccCreate, tx *types.Transaction, receiptData *types.ReceiptData, index int) (*types.LocalDBSet, error) {
+	if receiptData.GetTy() != types.ExecOk {
+		return &types.LocalDBSet{}, nil
+	}
+
+	kv, err := m.execLocalMultiSigReceipt(receiptData, tx, true)
+	if err != nil {
+		multisiglog.Error("ExecLocal_MultiSigAccCreate", "err", err)
+		return nil, err
+	}
+	return &types.LocalDBSet{KV: kv}, nil
+}
+
+//ExecLocal_MultiSigOwnerOperate 多重签名账户owner属性的修改：owner的add/del/replace/modify等
+func (m *MultiSig) ExecLocal_MultiSigOwnerOperate(payload *mty.MultiSigOwnerOperate, tx *types.Transaction, receiptData *types.ReceiptData, index int) (*types.LocalDBSet, error) {
+	if receiptData.GetTy() != types.ExecOk {
+		return &types.LocalDBSet{}, nil
+	}
+
+	kv, err := m.execLocalMultiSigReceipt(receiptData, tx, true)
+	if err != nil {
+		multisiglog.Error("ExecLocal_MultiSigOwnerOperate", "err", err)
+		return nil, err
+	}
+	return &types.LocalDBSet{KV: kv}, nil
+}
+
+//ExecLocal_MultiSigAccOperate 多重签名账户属性的修改：weight权重以及每日限额的修改
+func (m *MultiSig) ExecLocal_MultiSigAccOperate(payload *mty.MultiSigAccOperate, tx *types.Transaction, receiptData *types.ReceiptData, index int) (*types.LocalDBSet, error) {
+	if receiptData.GetTy() != types.ExecOk {
+		return &types.LocalDBSet{}, nil
+	}
+
+	kv, err := m.execLocalMultiSigReceipt(receiptData, tx, true)
+	if err != nil {
+		return nil, err
+	}
+	return &types.LocalDBSet{KV: kv}, nil
+}
+
+//ExecLocal_MultiSigConfirmTx 多重签名账户上交易的确认和撤销
+func (m *MultiSig) ExecLocal_MultiSigConfirmTx(payload *mty.MultiSigConfirmTx, tx *types.Transaction, receiptData *types.ReceiptData, index int) (*types.LocalDBSet, error) {
+	if receiptData.GetTy() != types.ExecOk {
+		return &types.LocalDBSet{}, nil
+	}
+
+	kv, err := m.execLocalMultiSigReceipt(receiptData, tx, true)
+	if err != nil {
+		multisiglog.Error("ExecLocal_MultiSigConfirmTx", "err", err)
+		return nil, err
+	}
+	return &types.LocalDBSet{KV: kv}, nil
+}
+
+//ExecLocal_MultiSigExecTransferTo 合约中外部账户转账到多重签名账户，Addr --->multiSigAddr
+func (m *MultiSig) ExecLocal_MultiSigExecTransferTo(payload *mty.MultiSigExecTransferTo, tx *types.Transaction, receiptData *types.ReceiptData, index int) (*types.LocalDBSet, error) {
+	if receiptData.GetTy() != types.ExecOk {
+		return &types.LocalDBSet{}, nil
+	}
+
+	kv, err := m.saveMultiSigTransfer(tx, mty.IsSubmit, true)
+	if err != nil {
+		multisiglog.Error("ExecLocal_MultiSigExecTransferTo", "err", err)
+		return nil, err
+	}
+	return &types.LocalDBSet{KV: kv}, nil
+}
+
+//ExecLocal_MultiSigExecTransferFrom 合约中多重签名账户转账到外部账户，multiSigAddr--->Addr
+func (m *MultiSig) ExecLocal_MultiSigExecTransferFrom(payload *mty.MultiSigExecTransferFrom, tx *types.Transaction, receiptData *types.ReceiptData, index int) (*types.LocalDBSet, error) {
+	if receiptData.GetTy() != types.ExecOk {
+		return &types.LocalDBSet{}, nil
+	}
+
+	kv, err := m.execLocalMultiSigReceipt(receiptData, tx, true)
+	if err != nil {
+		multisiglog.Error("ExecLocal_MultiSigExecTransferFrom", "err", err)
+		return nil, err
+	}
+	return &types.LocalDBSet{KV: kv}, nil
+}

plugin/dapp/multisig/executor/exec_test.go

+// Copyright Fuzamei Corp. 2018 All Rights Reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package executor
+
+import (
+	"testing"
+
+	"github.com/33cn/chain33/account"
+	"github.com/33cn/chain33/common"
+	commonlog "github.com/33cn/chain33/common/log"
+	drivers "github.com/33cn/chain33/system/dapp"
+	"github.com/stretchr/testify/assert"
+
+	apimock "github.com/33cn/chain33/client/mocks"
+	"github.com/33cn/chain33/common/address"
+	"github.com/33cn/chain33/common/crypto"
+	dbm "github.com/33cn/chain33/common/db"
+	dbmock "github.com/33cn/chain33/common/db/mocks"
+	"github.com/33cn/chain33/types"
+	mty "github.com/33cn/plugin/plugin/dapp/multisig/types"
+)
+
+type execEnv struct {
+	blockTime   int64 // 1539918074
+	blockHeight int64
+	index       int
+	difficulty  uint64
+	txHash      string
+}
+
+var (
+	Symbol = "BTY"
+	Asset  = "coins"
+
+	PrivKeyA = "0x6da92a632ab7deb67d38c0f6560bcfed28167998f6496db64c258d5e8393a81b" // 1KSBd17H7ZK8iT37aJztFB22XGwsPTdwE4
+	PrivKeyB = "0x19c069234f9d3e61135fefbeb7791b149cdf6af536f26bebb310d4cd22c3fee4" // 1JRNjdEqp4LJ5fqycUBm9ayCKSeeskgMKR
+	PrivKeyC = "0x7a80a1f75d7360c6123c32a78ecf978c1ac55636f87892df38d8b85a9aeff115" // 1NLHPEcbTWWxxU3dGUZBhayjrCHD3psX7k
+	PrivKeyD = "0xcacb1f5d51700aea07fca2246ab43b0917d70405c65edea9b5063d72eb5c6b71" // 1MCftFynyvG2F4ED5mdHYgziDxx6vDrScs
+	AddrA    = "1KSBd17H7ZK8iT37aJztFB22XGwsPTdwE4"
+	AddrB    = "1JRNjdEqp4LJ5fqycUBm9ayCKSeeskgMKR"
+	AddrC    = "1NLHPEcbTWWxxU3dGUZBhayjrCHD3psX7k"
+	AddrD    = "1MCftFynyvG2F4ED5mdHYgziDxx6vDrScs"
+
+	AddrBWeight           uint64 = 1
+	AddrCWeight           uint64 = 4
+	AddrDWeight           uint64 = 10
+	NewWeight             uint64 = 2
+	Requiredweight        uint64 = 5
+	NewRequiredweight     uint64 = 4
+	CoinsBtyDailylimit    uint64 = 100
+	NewCoinsBtyDailylimit uint64 = 10
+	PrintFlag                    = false
+	InAmount              int64  = 10
+	OutAmount             int64  = 5
+)
+
+func init() {
+	commonlog.SetLogLevel("debug")
+	types.AllowUserExec = append(types.AllowUserExec, []byte("coins"))
+
+}
+
+//创建一个多重签名的账户
+func TestMultiSigAccCreate(t *testing.T) {
+
+	total := int64(100000)
+	accountA := types.Account{
+		Balance: total,
+		Frozen:  0,
+		Addr:    AddrA,
+	}
+
+	accountD := types.Account{
+		Balance: total,
+		Frozen:  0,
+		Addr:    AddrD,
+	}
+
+	env := execEnv{
+		1539918074,
+		types.GetDappFork("multisig", "ForkMultiSigV1"),
+		2,
+		1539918074,
+		"hash",
+	}
+
+	stateDB, _ := dbm.NewGoMemDB("state", "state", 100)
+	localDB := new(dbmock.KVDB)
+	api := new(apimock.QueueProtocolAPI)
+
+	// 给账户accountB在multisig合约中写入coins-bty资产
+	accB := account.NewCoinsAccount()
+	accB.SetDB(stateDB)
+	accB.SaveExecAccount(address.ExecAddress("multisig"), &accountA)
+
+	// 给账户accountD在multisig合约中写入coins-bty资产
+	accD := account.NewCoinsAccount()
+	accD.SetDB(stateDB)
+	accD.SaveExecAccount(address.ExecAddress("multisig"), &accountD)
+
+	//accA, _ := account.NewAccountDB(AssetExecToken, Symbol, stateDB)
+	//accA.SaveExecAccount(address.ExecAddress("multisig"), &accountA)
+
+	driver := newMultiSig()
+	driver.SetEnv(env.blockHeight, env.blockTime, env.difficulty)
+	driver.SetStateDB(stateDB)
+	driver.SetLocalDB(localDB)
+	driver.SetAPI(api)
+
+	//add create MultiSigAcc
+	multiSigAddr, err := testMultiSigAccCreate(t, driver, env, localDB)
+	if err != nil {
+		assert.Nil(t, err, "exec failed")
+		return
+	}
+	//add addrB
+	//t.Log("------testMultiSigOwnerAdd------")
+	testMultiSigOwnerAdd(t, driver, env, multiSigAddr, AddrB, AddrBWeight)
+	//del addrB
+	//t.Log("------testMultiSigOwnerDel------")
+	testMultiSigOwnerDel(t, driver, env, multiSigAddr)
+	//modify addrC
+	//t.Log("------testMultiSigOwnerModify------")
+	testMultiSigOwnerModify(t, driver, env, multiSigAddr)
+	//replace addrC with addrB
+	//t.Log("------testMultiSigOwnerReplace------")
+	testMultiSigOwnerReplace(t, driver, env, multiSigAddr)
+	//modify NewRequiredweight
+	//t.Log("------testMultiSigAccWeightModify------")
+	testMultiSigAccWeightModify(t, driver, env, multiSigAddr)
+
+	//modify assets DailyLimit NewCoinsBtyDailylimit
+	//t.Log("------testMultiSigAccDailyLimitModify------")
+	testMultiSigAccDailyLimitModify(t, driver, env, multiSigAddr)
+
+	//confirmtx  assets DailyLimit NewCoinsBtyDailylimit
+	//t.Log("------testMultiSigAccConfirmTx------")
+	testMultiSigAccConfirmTx(t, driver, env, api, multiSigAddr)
+
+	//从外部账户转账到多重签名账户
+	//t.Log("------testMultiSigAccExecTransferTo------")
+	testMultiSigAccExecTransferTo(t, driver, env, multiSigAddr)
+
+	//从多重签名账户转账到外部账户
+	//t.Log("------testMultiSigAccExecTransferFrom------")
+	testMultiSigAccExecTransferFrom(t, driver, env, multiSigAddr)
+
+}
+
+func testMultiSigAccCreate(t *testing.T, driver drivers.Driver, env execEnv, localDB *dbmock.KVDB) (string, error) {
+	//---------测试账户创建--------------------
+	var owners []*mty.Owner
+	owmer1 := &mty.Owner{OwnerAddr: AddrC, Weight: AddrCWeight}
+	owners = append(owners, owmer1)
+	owmer2 := &mty.Owner{OwnerAddr: AddrD, Weight: AddrDWeight}
+	owners = append(owners, owmer2)
+
+	symboldailylimit := &mty.SymbolDailyLimit{
+		Symbol:     Symbol,
+		Execer:     "coins",
+		DailyLimit: CoinsBtyDailylimit,
+	}
+
+	param := &mty.MultiSigAccCreate{
+		Owners:         owners,
+		RequiredWeight: Requiredweight,
+		DailyLimit:     symboldailylimit,
+	}
+
+	tx, _ := multiSigAccCreate(param)
+	tx, _ = signTx(tx, PrivKeyA)
+
+	addr := address.MultiSignAddress(tx.Hash())
+	localDB.On("Get", calcMultiSigAcc(addr)).Return(nil, types.ErrNotFound)
+
+	receipt, err := driver.Exec(tx, env.index)
+	if err != nil {
+		assert.Nil(t, err, "exec failed")
+		return "", err
+	}
+
+	//解析kv
+	var multiSigAccount mty.MultiSig
+	err = types.Decode(receipt.KV[0].Value, &multiSigAccount)
+	assert.Nil(t, err, "decode account")
+	////t.Log(multiSigAccount)
+
+	//解析log
+	var receiptMultiSig mty.MultiSig
+	ty := receipt.Logs[0].Ty
+	////t.Log(ty)
+	err = types.Decode(receipt.Logs[0].Log, &receiptMultiSig)
+	assert.Nil(t, err, "decode Logs")
+	//t.Log(receiptMultiSig)
+	assert.Equal(t, int(ty), mty.TyLogMultiSigAccCreate)
+
+	return receiptMultiSig.MultiSigAddr, nil
+
+}
+
+func testMultiSigOwnerAdd(t *testing.T, driver drivers.Driver, env execEnv, multiSigAddr, addr string, weight uint64) {
+	params := &mty.MultiSigOwnerOperate{
+		MultiSigAccAddr: multiSigAddr,
+		NewOwner:        addr,
+		NewWeight:       weight,
+		OperateFlag:     mty.OwnerAdd,
+	}
+
+	tx, _ := multiSigOwnerOperate(params)
+	tx, _ = signTx(tx, PrivKeyD)
+
+	receipt, err := driver.Exec(tx, env.index)
+	if err != nil {
+		assert.Nil(t, err, "exec failed")
+		return
+	}
+
+	var multiSigAccount mty.MultiSig
+	//解析kv0
+	//t.Log("TyLogMultiSigOwnerAdd kv & log ")
+	err = types.Decode(receipt.KV[0].Value, &multiSigAccount)
+	assert.Nil(t, err, "decode account")
+	//t.Log(multiSigAccount)
+
+	//解析log0
+	var receiptMultiSigOwnerAddOrDel mty.ReceiptOwnerAddOrDel
+	ty := receipt.Logs[0].Ty
+	//t.Log(ty)
+	err = types.Decode(receipt.Logs[0].Log, &receiptMultiSigOwnerAddOrDel)
+	assert.Nil(t, err, "decode Logs")
+	//t.Log(receiptMultiSigOwnerAddOrDel)
+	assert.Equal(t, int(ty), mty.TyLogMultiSigOwnerAdd)
+
+	//解析kv1
+	//t.Log("TyLogTxCountUpdate kv & log ")
+	err = types.Decode(receipt.KV[1].Value, &multiSigAccount)
+	assert.Nil(t, err, "decode account")
+	//t.Log(multiSigAccount)
+
+	//解析log1
+	var receiptTxCountUpdate mty.ReceiptTxCountUpdate
+	ty = receipt.Logs[1].Ty
+	//t.Log(ty)
+	err = types.Decode(receipt.Logs[1].Log, &receiptTxCountUpdate)
+	assert.Nil(t, err, "decode Logs")
+	//t.Log(receiptTxCountUpdate)
+	assert.Equal(t, int(ty), mty.TyLogTxCountUpdate)
+
+	//解析kv2
+	//t.Log("TyLogMultiSigTx kv & log ")
+	var multiSigTx mty.MultiSigTx
+	err = types.Decode(receipt.KV[2].Value, &multiSigTx)
+	assert.Nil(t, err, "decode account")
+	//t.Log(multiSigTx)
+
+	//解析log2
+	var receiptAccExecTransferTx mty.ReceiptMultiSigTx
+	ty = receipt.Logs[2].Ty
+	//t.Log(ty)
+	err = types.Decode(receipt.Logs[2].Log, &receiptAccExecTransferTx)
+	assert.Nil(t, err, "decode Logs")
+	//t.Log(receiptAccExecTransferTx)
+	assert.Equal(t, int(ty), mty.TyLogMultiSigTx)
+}
+
+func testMultiSigOwnerDel(t *testing.T, driver drivers.Driver, env execEnv, multiSigAddr string) {
+	params := &mty.MultiSigOwnerOperate{
+		MultiSigAccAddr: multiSigAddr,
+		OldOwner:        AddrB,
+		OperateFlag:     mty.OwnerDel,
+	}
+
+	tx, _ := multiSigOwnerOperate(params)
+	tx, _ = signTx(tx, PrivKeyD)
+
+	receipt, err := driver.Exec(tx, env.index)
+	if err != nil {
+		assert.Nil(t, err, "exec failed")
+		return
+	}
+
+	var multiSigAccount mty.MultiSig
+	//解析kv0
+	//t.Log("TyLogMultiSigOwnerDel kv & log ")
+	err = types.Decode(receipt.KV[0].Value, &multiSigAccount)
+	assert.Nil(t, err, "decode account")
+	//t.Log(multiSigAccount)
+
+	//解析log0
+	var receiptMultiSigOwnerAddOrDel mty.ReceiptOwnerAddOrDel
+	ty := receipt.Logs[0].Ty
+	//t.Log(ty)
+	err = types.Decode(receipt.Logs[0].Log, &receiptMultiSigOwnerAddOrDel)
+	assert.Nil(t, err, "decode Logs")
+	//t.Log(receiptMultiSigOwnerAddOrDel)
+	assert.Equal(t, int(ty), mty.TyLogMultiSigOwnerDel)
+
+	//解析kv1
+	//t.Log("TyLogTxCountUpdate kv & log ")
+	err = types.Decode(receipt.KV[1].Value, &multiSigAccount)
+	assert.Nil(t, err, "decode account")
+	//t.Log(multiSigAccount)
+
+	//解析log1
+	var receiptTxCountUpdate mty.ReceiptTxCountUpdate
+	ty = receipt.Logs[1].Ty
+	//t.Log(ty)
+	err = types.Decode(receipt.Logs[1].Log, &receiptTxCountUpdate)
+	assert.Nil(t, err, "decode Logs")
+	//t.Log(receiptTxCountUpdate)
+	assert.Equal(t, int(ty), mty.TyLogTxCountUpdate)
+
+	//解析kv2
+	//t.Log("TyLogMultiSigTx kv & log ")
+	var multiSigTx mty.MultiSigTx
+	err = types.Decode(receipt.KV[2].Value, &multiSigTx)
+	assert.Nil(t, err, "decode account")
+	//t.Log(multiSigTx)
+
+	//解析log2
+	var receiptAccExecTransferTx mty.ReceiptMultiSigTx
+	ty = receipt.Logs[2].Ty
+	//t.Log(ty)
+	err = types.Decode(receipt.Logs[2].Log, &receiptAccExecTransferTx)
+	assert.Nil(t, err, "decode Logs")
+	//t.Log(receiptAccExecTransferTx)
+	assert.Equal(t, int(ty), mty.TyLogMultiSigTx)
+}
+func testMultiSigOwnerModify(t *testing.T, driver drivers.Driver, env execEnv, multiSigAddr string) {
+	params := &mty.MultiSigOwnerOperate{
+		MultiSigAccAddr: multiSigAddr,
+		OldOwner:        AddrC,
+		NewWeight:       NewWeight,
+		OperateFlag:     mty.OwnerModify,
+	}
+	tx, _ := multiSigOwnerOperate(params)
+	tx, _ = signTx(tx, PrivKeyD)
+
+	receipt, err := driver.Exec(tx, env.index)
+	if err != nil {
+		assert.Nil(t, err, "exec failed")
+		return
+	}
+
+	var multiSigAccount mty.MultiSig
+	//解析kv0
+	//t.Log("TyLogMultiSigOwnerModify kv & log ")
+	err = types.Decode(receipt.KV[0].Value, &multiSigAccount)
+	assert.Nil(t, err, "decode account")
+	//t.Log(multiSigAccount)
+
+	//解析log0
+	var receiptMultiSigOwnerModOrRep mty.ReceiptOwnerModOrRep
+	ty := receipt.Logs[0].Ty
+	//t.Log(ty)
+	err = types.Decode(receipt.Logs[0].Log, &receiptMultiSigOwnerModOrRep)
+	assert.Nil(t, err, "decode Logs")
+	//t.Log(receiptMultiSigOwnerModOrRep)
+	assert.Equal(t, int(ty), mty.TyLogMultiSigOwnerModify)
+
+	assert.Equal(t, receiptMultiSigOwnerModOrRep.PrevOwner.OwnerAddr, AddrC)
+	assert.Equal(t, receiptMultiSigOwnerModOrRep.CurrentOwner.OwnerAddr, AddrC)
+
+	//assert.Equal(t, receiptMultiSigOwnerModOrRep.PrevOwner.Weight, addrC)
+	assert.Equal(t, receiptMultiSigOwnerModOrRep.CurrentOwner.Weight, NewWeight)
+	assert.Equal(t, receiptMultiSigOwnerModOrRep.ModOrRep, true)
+
+	//解析kv1
+	//t.Log("TyLogTxCountUpdate kv & log ")
+	err = types.Decode(receipt.KV[1].Value, &multiSigAccount)
+	assert.Nil(t, err, "decode account")
+	//t.Log(multiSigAccount)
+
+	//解析log1
+	var receiptTxCountUpdate mty.ReceiptTxCountUpdate
+	ty = receipt.Logs[1].Ty
+	//t.Log(ty)
+	err = types.Decode(receipt.Logs[1].Log, &receiptTxCountUpdate)
+	assert.Nil(t, err, "decode Logs")
+	//t.Log(receiptTxCountUpdate)
+	assert.Equal(t, int(ty), mty.TyLogTxCountUpdate)
+	assert.Equal(t, uint64(3), receiptTxCountUpdate.CurTxCount)
+
+	//解析kv2
+	//t.Log("TyLogMultiSigTx kv & log ")
+	var multiSigTx mty.MultiSigTx
+	err = types.Decode(receipt.KV[2].Value, &multiSigTx)
+	assert.Nil(t, err, "decode account")
+	//t.Log(multiSigTx)
+
+	//解析log2
+	var receiptAccExecTransferTx mty.ReceiptMultiSigTx
+	ty = receipt.Logs[2].Ty
+	//t.Log(ty)
+	err = types.Decode(receipt.Logs[2].Log, &receiptAccExecTransferTx)
+	assert.Nil(t, err, "decode Logs")
+	//t.Log(receiptAccExecTransferTx)
+	assert.Equal(t, int(ty), mty.TyLogMultiSigTx)
+}
+func testMultiSigOwnerReplace(t *testing.T, driver drivers.Driver, env execEnv, multiSigAddr string) {
+	params := &mty.MultiSigOwnerOperate{
+		MultiSigAccAddr: multiSigAddr,
+		OldOwner:        AddrC,
+		NewWeight:       AddrBWeight,
+		NewOwner:        AddrB,
+		OperateFlag:     mty.OwnerReplace,
+	}
+	tx, _ := multiSigOwnerOperate(params)
+	tx, _ = signTx(tx, PrivKeyD)
+
+	receipt, err := driver.Exec(tx, env.index)
+	if err != nil {
+		assert.Nil(t, err, "exec failed")
+		return
+	}
+
+	var multiSigAccount mty.MultiSig
+	//解析kv0
+	//t.Log("TyLogMultiSigOwnerReplace kv & log ")
+	err = types.Decode(receipt.KV[0].Value, &multiSigAccount)
+	assert.Nil(t, err, "decode account")
+	//t.Log(multiSigAccount)
+	//解析log0
+	var receiptMultiSigOwnerModOrRep mty.ReceiptOwnerModOrRep
+	ty := receipt.Logs[0].Ty
+	//t.Log(ty)
+	err = types.Decode(receipt.Logs[0].Log, &receiptMultiSigOwnerModOrRep)
+	assert.Nil(t, err, "decode Logs")
+	//t.Log(receiptMultiSigOwnerModOrRep)
+	assert.Equal(t, int(ty), mty.TyLogMultiSigOwnerReplace)
+	assert.Equal(t, receiptMultiSigOwnerModOrRep.PrevOwner.OwnerAddr, AddrC)
+	assert.Equal(t, receiptMultiSigOwnerModOrRep.CurrentOwner.OwnerAddr, AddrB)
+	assert.Equal(t, receiptMultiSigOwnerModOrRep.ModOrRep, false)
+
+	//解析kv1
+	//t.Log("TyLogTxCountUpdate kv & log ")
+	err = types.Decode(receipt.KV[1].Value, &multiSigAccount)
+	assert.Nil(t, err, "decode account")
+	//t.Log(multiSigAccount)
+	//解析log1
+	var receiptTxCountUpdate mty.ReceiptTxCountUpdate
+	ty = receipt.Logs[1].Ty
+	//t.Log(ty)
+	err = types.Decode(receipt.Logs[1].Log, &receiptTxCountUpdate)
+	assert.Nil(t, err, "decode Logs")
+	//t.Log(receiptTxCountUpdate)
+	assert.Equal(t, int(ty), mty.TyLogTxCountUpdate)
+	assert.Equal(t, uint64(4), receiptTxCountUpdate.CurTxCount)
+
+	//解析kv2
+	//t.Log("TyLogMultiSigTx kv & log ")
+	var multiSigTx mty.MultiSigTx
+	err = types.Decode(receipt.KV[2].Value, &multiSigTx)
+	assert.Nil(t, err, "decode account")
+	//t.Log(multiSigTx)
+	//解析log2
+	var receiptAccExecTransferTx mty.ReceiptMultiSigTx
+	ty = receipt.Logs[2].Ty
+	//t.Log(ty)
+	err = types.Decode(receipt.Logs[2].Log, &receiptAccExecTransferTx)
+	assert.Nil(t, err, "decode Logs")
+	//t.Log(receiptAccExecTransferTx)
+	assert.Equal(t, int(ty), mty.TyLogMultiSigTx)
+}
+
+//account 操作测试
+func testMultiSigAccWeightModify(t *testing.T, driver drivers.Driver, env execEnv, multiSigAddr string) {
+	params := &mty.MultiSigAccOperate{
+		MultiSigAccAddr:   multiSigAddr,
+		NewRequiredWeight: NewRequiredweight,
+		OperateFlag:       mty.AccWeightOp,
+	}
+
+	tx, _ := multiSigAccOperate(params)
+	tx, _ = signTx(tx, PrivKeyD)
+
+	receipt, err := driver.Exec(tx, env.index)
+	if err != nil {
+		assert.Nil(t, err, "exec failed")
+		return
+	}
+
+	var multiSigAccount mty.MultiSig
+	//解析kv0
+	//t.Log("TyLogMultiSigAccWeightModify kv & log ")
+	err = types.Decode(receipt.KV[0].Value, &multiSigAccount)
+	assert.Nil(t, err, "decode account")
+	//t.Log(multiSigAccount)
+	//解析log0
+	var receiptMultiSigWeightModify mty.ReceiptWeightModify
+	ty := receipt.Logs[0].Ty
+	//t.Log(ty)
+	err = types.Decode(receipt.Logs[0].Log, &receiptMultiSigWeightModify)
+	assert.Nil(t, err, "decode Logs")
+	//t.Log(receiptMultiSigWeightModify)
+
+	assert.Equal(t, int(ty), mty.TyLogMultiSigAccWeightModify)
+
+	assert.Equal(t, Requiredweight, receiptMultiSigWeightModify.PrevWeight)
+	assert.Equal(t, NewRequiredweight, receiptMultiSigWeightModify.CurrentWeight)
+
+	//解析kv1
+	//t.Log("TyLogTxCountUpdate kv & log ")
+	err = types.Decode(receipt.KV[1].Value, &multiSigAccount)
+	assert.Nil(t, err, "decode account")
+	//t.Log(multiSigAccount)
+	//解析log1
+	var receiptTxCountUpdate mty.ReceiptTxCountUpdate
+	ty = receipt.Logs[1].Ty
+	//t.Log(ty)
+	err = types.Decode(receipt.Logs[1].Log, &receiptTxCountUpdate)
+	assert.Nil(t, err, "decode Logs")
+	//t.Log(receiptTxCountUpdate)
+	assert.Equal(t, int(ty), mty.TyLogTxCountUpdate)
+	assert.Equal(t, uint64(5), receiptTxCountUpdate.CurTxCount)
+
+	//解析kv2
+	//t.Log("TyLogMultiSigTx kv & log ")
+	var multiSigTx mty.MultiSigTx
+	err = types.Decode(receipt.KV[2].Value, &multiSigTx)
+	assert.Nil(t, err, "decode account")
+	//t.Log(multiSigTx)
+	//解析log2
+	var receiptAccExecTransferTx mty.ReceiptMultiSigTx
+	ty = receipt.Logs[2].Ty
+	//t.Log(ty)
+	err = types.Decode(receipt.Logs[2].Log, &receiptAccExecTransferTx)
+	assert.Nil(t, err, "decode Logs")
+	//t.Log(receiptAccExecTransferTx)
+	assert.Equal(t, int(ty), mty.TyLogMultiSigTx)
+}
+func testMultiSigAccDailyLimitModify(t *testing.T, driver drivers.Driver, env execEnv, multiSigAddr string) {
+	assetsDailyLimit := &mty.SymbolDailyLimit{
+		Symbol:     Symbol,
+		Execer:     Asset,
+		DailyLimit: NewCoinsBtyDailylimit,
+	}
+	params := &mty.MultiSigAccOperate{
+		MultiSigAccAddr: multiSigAddr,
+		DailyLimit:      assetsDailyLimit,
+		OperateFlag:     mty.AccDailyLimitOp,
+	}
+
+	tx, _ := multiSigAccOperate(params)
+	tx, _ = signTx(tx, PrivKeyD)
+
+	receipt, err := driver.Exec(tx, env.index)
+	if err != nil {
+		assert.Nil(t, err, "exec failed")
+		return
+	}
+
+	var multiSigAccount mty.MultiSig
+	//解析kv0
+	//t.Log("TyLogMultiSigAccDailyLimitModify kv & log ")
+	err = types.Decode(receipt.KV[0].Value, &multiSigAccount)
+	assert.Nil(t, err, "decode account")
+	//t.Log(multiSigAccount)
+	//解析log0
+	var receiptMultiSigDailyLimitOperate mty.ReceiptDailyLimitOperate
+	ty := receipt.Logs[0].Ty
+	//t.Log(ty)
+	err = types.Decode(receipt.Logs[0].Log, &receiptMultiSigDailyLimitOperate)
+	assert.Nil(t, err, "decode Logs")
+	//t.Log(receiptMultiSigDailyLimitOperate)
+
+	assert.Equal(t, int(ty), mty.TyLogMultiSigAccDailyLimitModify)
+
+	assert.Equal(t, receiptMultiSigDailyLimitOperate.PrevDailyLimit.Symbol, Symbol)
+	assert.Equal(t, receiptMultiSigDailyLimitOperate.PrevDailyLimit.Execer, Asset)
+	assert.Equal(t, receiptMultiSigDailyLimitOperate.PrevDailyLimit.DailyLimit, CoinsBtyDailylimit)
+
+	assert.Equal(t, receiptMultiSigDailyLimitOperate.PrevDailyLimit.Symbol, Symbol)
+	assert.Equal(t, receiptMultiSigDailyLimitOperate.PrevDailyLimit.Execer, Asset)
+	assert.Equal(t, receiptMultiSigDailyLimitOperate.CurDailyLimit.DailyLimit, NewCoinsBtyDailylimit)
+
+	//解析kv1
+	//t.Log("TyLogTxCountUpdate kv & log ")
+	err = types.Decode(receipt.KV[1].Value, &multiSigAccount)
+	assert.Nil(t, err, "decode account")
+	//t.Log(multiSigAccount)
+	//解析log1
+	var receiptTxCountUpdate mty.ReceiptTxCountUpdate
+	ty = receipt.Logs[1].Ty
+	//t.Log(ty)
+	err = types.Decode(receipt.Logs[1].Log, &receiptTxCountUpdate)
+	assert.Nil(t, err, "decode Logs")
+	//t.Log(receiptTxCountUpdate)
+	assert.Equal(t, int(ty), mty.TyLogTxCountUpdate)
+	assert.Equal(t, uint64(6), receiptTxCountUpdate.CurTxCount)
+
+	//解析kv2
+	//t.Log("TyLogMultiSigTx kv & log ")
+	var multiSigTx mty.MultiSigTx
+	err = types.Decode(receipt.KV[2].Value, &multiSigTx)
+	assert.Nil(t, err, "decode account")
+	//t.Log(multiSigTx)
+	//解析log2
+	var receiptAccExecTransferTx mty.ReceiptMultiSigTx
+	ty = receipt.Logs[2].Ty
+	//t.Log(ty)
+	err = types.Decode(receipt.Logs[2].Log, &receiptAccExecTransferTx)
+	assert.Nil(t, err, "decode Logs")
+	//t.Log(receiptAccExecTransferTx)
+	assert.Equal(t, int(ty), mty.TyLogMultiSigTx)
+
+}
+
+//account 操作测试
+//当前账户的信息，txcount：6 Requiredweight:4
+//ownerAddr:"1JRNjdEqp4LJ5fqycUBm9ayCKSeeskgMKR" weight:2
+//ownerAddr:"1MCftFynyvG2F4ED5mdHYgziDxx6vDrScs" weight:10 ]
+//[symbol:"bty" execer:"coins" dailyLimit:10 ]
+//6
+// 4}
+func testMultiSigAccConfirmTx(t *testing.T, driver drivers.Driver, env execEnv, api *apimock.QueueProtocolAPI, multiSigAddr string) {
+	//首先创建一个修改Requiredweight权重的交易。由AddrB提交此交易，权限不够交易不被执行。
+	//然后由权重比较高的AddrD owner再次提交确认此交易，交易被执行完成
+
+	params := &mty.MultiSigAccOperate{
+		MultiSigAccAddr:   multiSigAddr,
+		NewRequiredWeight: Requiredweight,
+		OperateFlag:       mty.AccWeightOp,
+	}
+
+	tx, _ := multiSigAccOperate(params)
+	tx, _ = signTx(tx, PrivKeyB)
+
+	receipt, err := driver.Exec(tx, env.index)
+	if err != nil {
+		assert.Nil(t, err, "exec failed")
+		return
+	}
+
+	var multiSigAccount mty.MultiSig
+
+	//解析kv&log0
+	//t.Log("TyLogTxCountUpdate kv & log ")
+	err = types.Decode(receipt.KV[0].Value, &multiSigAccount)
+	assert.Nil(t, err, "decode account")
+	//t.Log(multiSigAccount)
+
+	var receiptTxCountUpdate mty.ReceiptTxCountUpdate
+	ty := receipt.Logs[0].Ty
+	//t.Log(ty)
+	err = types.Decode(receipt.Logs[0].Log, &receiptTxCountUpdate)
+	assert.Nil(t, err, "decode Logs")
+	//t.Log(receiptTxCountUpdate)
+	assert.Equal(t, int(ty), mty.TyLogTxCountUpdate)
+	assert.Equal(t, uint64(7), receiptTxCountUpdate.CurTxCount)
+
+	//解析kv&log[1]
+	//t.Log("TyLogMultiSigTx kv & log ")
+	var multiSigTx mty.MultiSigTx
+	err = types.Decode(receipt.KV[1].Value, &multiSigTx)
+	assert.Nil(t, err, "decode account")
+	//t.Log(multiSigTx)
+
+	var receiptAccExecTransferTx mty.ReceiptMultiSigTx
+	ty = receipt.Logs[1].Ty
+	//t.Log(ty)
+	err = types.Decode(receipt.Logs[1].Log, &receiptAccExecTransferTx)
+	assert.Nil(t, err, "decode Logs")
+	//t.Log(receiptAccExecTransferTx)
+	assert.Equal(t, int(ty), mty.TyLogMultiSigTx)
+	assert.Equal(t, false, receiptAccExecTransferTx.CurExecuted)
+
+	txid := receiptAccExecTransferTx.MultiSigTxOwner.Txid
+
+	//构造api接口
+	txDetails := &types.TransactionDetails{}
+	txDetail := &types.TransactionDetail{
+		Tx: tx,
+	}
+	txDetails.Txs = append(txDetails.Txs, txDetail)
+	api.On("GetTransactionByHash", &types.ReqHashes{Hashes: [][]byte{tx.Hash()}}).Return(txDetails, nil)
+
+	//让addrB owner撤销此确认交易
+	//t.Log("-----MultiSigConfirmTx Revoke  -----")
+	param := &mty.MultiSigConfirmTx{
+		MultiSigAccAddr: multiSigAddr,
+		TxId:            txid,
+		ConfirmOrRevoke: false,
+	}
+
+	txConfirm, _ := multiSigConfirmTx(param)
+	txConfirm, _ = signTx(txConfirm, PrivKeyB)
+
+	receipt, err = driver.Exec(txConfirm, env.index)
+	if err != nil {
+		assert.Nil(t, err, "exec failed")
+		return
+	}
+
+	//解析kv0
+	//t.Log("ReceiptConfirmTx kv & log ")
+	err = types.Decode(receipt.KV[0].Value, &multiSigTx)
+	assert.Nil(t, err, "decode account")
+	//t.Log(multiSigTx)
+	//解析log0
+	var receiptMultiSigConfirmTx mty.ReceiptConfirmTx
+	ty = receipt.Logs[0].Ty
+	//t.Log(ty)
+	err = types.Decode(receipt.Logs[0].Log, &receiptMultiSigConfirmTx)
+	assert.Nil(t, err, "decode Logs")
+	//t.Log(receiptMultiSigConfirmTx)
+
+	assert.Equal(t, int(ty), mty.TyLogMultiSigConfirmTxRevoke)
+	assert.Equal(t, false, receiptMultiSigConfirmTx.ConfirmeOrRevoke)
+	assert.Equal(t, AddrB, receiptMultiSigConfirmTx.MultiSigTxOwner.ConfirmedOwner.OwnerAddr)
+
+	//t.Log("-----MultiSigConfirmTx Confirm  -----")
+	//让addrD owner来确认此交易
+	para := &mty.MultiSigConfirmTx{
+		MultiSigAccAddr: multiSigAddr,
+		TxId:            txid,
+		ConfirmOrRevoke: true,
+	}
+
+	txConfirm, _ = multiSigConfirmTx(para)
+	txConfirm, _ = signTx(txConfirm, PrivKeyD)
+
+	receipt, err = driver.Exec(txConfirm, env.index)
+	if err != nil {
+		assert.Nil(t, err, "exec failed")
+		return
+	}
+
+	//解析kv0
+	//t.Log("TyLogMultiSigAccWeightModify kv & log ")
+	err = types.Decode(receipt.KV[0].Value, &multiSigAccount)
+	assert.Nil(t, err, "decode account")
+	//t.Log(multiSigAccount)
+	//解析log0
+	var receiptMultiSigWeightModify mty.ReceiptWeightModify
+	ty = receipt.Logs[0].Ty
+	//t.Log(ty)
+	err = types.Decode(receipt.Logs[0].Log, &receiptMultiSigWeightModify)
+	assert.Nil(t, err, "decode Logs")
+	//t.Log(receiptMultiSigWeightModify)
+
+	assert.Equal(t, int(ty), mty.TyLogMultiSigAccWeightModify)
+
+	assert.Equal(t, NewRequiredweight, receiptMultiSigWeightModify.PrevWeight)
+	assert.Equal(t, Requiredweight, receiptMultiSigWeightModify.CurrentWeight)
+
+	//解析kv&log[1]
+	//t.Log("TyLogMultiSigTx kv & log ")
+	err = types.Decode(receipt.KV[1].Value, &multiSigTx)
+	assert.Nil(t, err, "decode account")
+	//t.Log(multiSigTx)
+
+	ty = receipt.Logs[1].Ty
+	//t.Log(ty)
+	err = types.Decode(receipt.Logs[1].Log, &receiptAccExecTransferTx)
+	assert.Nil(t, err, "decode Logs")
+	//t.Log(receiptAccExecTransferTx)
+	assert.Equal(t, int(ty), mty.TyLogMultiSigTx)
+	assert.Equal(t, true, receiptAccExecTransferTx.CurExecuted)
+
+}
+
+//合约内转账到多重签名账户
+func testMultiSigAccExecTransferTo(t *testing.T, driver drivers.Driver, env execEnv, multiSigAddr string) {
+	params := &mty.MultiSigExecTransferTo{
+		Symbol:   Symbol,
+		Amount:   InAmount,
+		Note:     "testMultiSigAccExecTransferTo",
+		Execname: Asset,
+		To:       multiSigAddr,
+	}
+
+	tx, _ := multiSigExecTransferTo(params, false)
+	tx, _ = signTx(tx, PrivKeyD)
+
+	receipt, err := driver.Exec(tx, env.index)
+	if err != nil {
+		assert.Nil(t, err, "exec failed")
+		return
+	}
+	var acc types.Account
+	var receiptExecAccountTransfer types.ReceiptExecAccountTransfer
+
+	//解析kv0
+	//t.Log("TyLogExecTransfer kv & log ")
+	err = types.Decode(receipt.KV[0].Value, &acc)
+	assert.Nil(t, err, "decode account")
+	//t.Log(acc)
+	//解析log0
+	ty := receipt.Logs[0].Ty
+	//t.Log(ty)
+	err = types.Decode(receipt.Logs[0].Log, &receiptExecAccountTransfer)
+	assert.Nil(t, err, "decode Logs")
+	//t.Log(receiptExecAccountTransfer)
+
+	assert.Equal(t, int(ty), types.TyLogExecTransfer)
+
+	assert.Equal(t, receiptExecAccountTransfer.Current.Balance+InAmount, receiptExecAccountTransfer.Prev.Balance)
+	//assert.Equal(t, NewRequiredweight, receiptMultiSigWeightModify.CurrentWeight)
+
+	//解析kv1
+	//t.Log("TyLogExecTransfer kv & log ")
+	err = types.Decode(receipt.KV[1].Value, &acc)
+	assert.Nil(t, err, "decode account")
+	//t.Log(acc)
+	//解析log0
+	ty = receipt.Logs[1].Ty
+	//t.Log(ty)
+	err = types.Decode(receipt.Logs[1].Log, &receiptExecAccountTransfer)
+	assert.Nil(t, err, "decode Logs")
+	//t.Log(receiptExecAccountTransfer)
+
+	assert.Equal(t, int(ty), types.TyLogExecTransfer)
+	assert.Equal(t, receiptExecAccountTransfer.Current.Balance, receiptExecAccountTransfer.Prev.Balance+InAmount)
+
+	//解析kv2
+	//t.Log("TyLogExecFrozen kv & log ")
+	err = types.Decode(receipt.KV[2].Value, &acc)
+	assert.Nil(t, err, "decode account")
+	//t.Log(acc)
+	//解析log0
+	ty = receipt.Logs[2].Ty
+	//t.Log(ty)
+	err = types.Decode(receipt.Logs[2].Log, &receiptExecAccountTransfer)
+	assert.Nil(t, err, "decode Logs")
+	//t.Log(receiptExecAccountTransfer)
+
+	assert.Equal(t, int(ty), types.TyLogExecFrozen)
+	assert.Equal(t, receiptExecAccountTransfer.Prev.Balance, InAmount)
+	assert.Equal(t, receiptExecAccountTransfer.Current.Frozen, InAmount)
+	assert.Equal(t, receiptExecAccountTransfer.Current.Balance, receiptExecAccountTransfer.Prev.Balance-InAmount)
+
+}
+
+//合约内转账到多重签名账户
+func testMultiSigAccExecTransferFrom(t *testing.T, driver drivers.Driver, env execEnv, multiSigAddr string) {
+	params := &mty.MultiSigExecTransferFrom{
+		Symbol:   Symbol,
+		Amount:   OutAmount,
+		Note:     "testMultiSigAccExecTransferFrom",
+		Execname: Asset,
+		From:     multiSigAddr,
+		To:       AddrD,
+	}
+
+	tx, _ := multiSigExecTransferFrom(params, true)
+	tx, _ = signTx(tx, PrivKeyB)
+
+	receipt, err := driver.Exec(tx, env.index)
+	if err != nil {
+		assert.Nil(t, err, "exec failed")
+		return
+	}
+	var multiSigAcc mty.MultiSig
+	var acc types.Account
+	var receiptExecAccountTransfer types.ReceiptExecAccountTransfer
+
+	//解析kv0
+	//t.Log("TyLogExecTransfer kv & log ")
+	err = types.Decode(receipt.KV[0].Value, &acc)
+	assert.Nil(t, err, "decode account")
+	//t.Log(acc)
+	//解析log0
+	ty := receipt.Logs[0].Ty
+	//t.Log(ty)
+	err = types.Decode(receipt.Logs[0].Log, &receiptExecAccountTransfer)
+	assert.Nil(t, err, "decode Logs")
+	//t.Log(receiptExecAccountTransfer)
+	assert.Equal(t, int(ty), types.TyLogExecTransfer)
+	assert.Equal(t, receiptExecAccountTransfer.Current.Frozen, receiptExecAccountTransfer.Prev.Frozen-OutAmount)
+
+	//解析kv1
+	//t.Log("TyLogExecTransfer kv & log ")
+	err = types.Decode(receipt.KV[1].Value, &acc)
+	assert.Nil(t, err, "decode account")
+	//t.Log(acc)
+	ty = receipt.Logs[1].Ty
+	//t.Log(ty)
+	err = types.Decode(receipt.Logs[1].Log, &receiptExecAccountTransfer)
+	assert.Nil(t, err, "decode Logs")
+	//t.Log(receiptExecAccountTransfer)
+
+	assert.Equal(t, int(ty), types.TyLogExecTransfer)
+	assert.Equal(t, receiptExecAccountTransfer.Current.Balance, receiptExecAccountTransfer.Prev.Balance+OutAmount)
+
+	//解析kv2
+	var receiptTxCountUpdate mty.ReceiptTxCountUpdate
+	//t.Log("TyLogTxCountUpdate kv & log ")
+	err = types.Decode(receipt.KV[2].Value, &multiSigAcc)
+	assert.Nil(t, err, "decode account")
+	//t.Log(multiSigAcc)
+	ty = receipt.Logs[2].Ty
+	//t.Log(ty)
+	err = types.Decode(receipt.Logs[2].Log, &receiptTxCountUpdate)
+	assert.Nil(t, err, "decode Logs")
+	//t.Log(receiptTxCountUpdate)
+	assert.Equal(t, int(ty), mty.TyLogTxCountUpdate)
+
+	//解析kv3
+	var receiptAccDailyLimitUpdate mty.ReceiptAccDailyLimitUpdate
+	//t.Log("TyLogDailyLimitUpdate kv & log ")
+	err = types.Decode(receipt.KV[3].Value, &multiSigAcc)
+	assert.Nil(t, err, "decode account")
+	//t.Log(multiSigAcc)
+	ty = receipt.Logs[3].Ty
+	//t.Log(ty)
+	err = types.Decode(receipt.Logs[3].Log, &receiptAccDailyLimitUpdate)
+	assert.Nil(t, err, "decode Logs")
+	//t.Log(receiptAccDailyLimitUpdate)
+	assert.Equal(t, int(ty), mty.TyLogDailyLimitUpdate)
+
+	//解析kv4
+	var receiptAccExecTransferTx mty.ReceiptMultiSigTx
+	var multiSigTx mty.MultiSigTx
+	//t.Log("TyLogExecTransfer kv & log ")
+	err = types.Decode(receipt.KV[4].Value, &multiSigTx)
+	assert.Nil(t, err, "decode account")
+	//t.Log(multiSigTx)
+	//解析log0
+	ty = receipt.Logs[4].Ty
+	//t.Log(ty)
+	err = types.Decode(receipt.Logs[4].Log, &receiptAccExecTransferTx)
+	assert.Nil(t, err, "decode Logs")
+	//t.Log(receiptAccExecTransferTx)
+	assert.Equal(t, int(ty), mty.TyLogMultiSigTx)
+
+}
+
+func signTx(tx *types.Transaction, hexPrivKey string) (*types.Transaction, error) {
+	signType := types.SECP256K1
+	c, err := crypto.New(types.GetSignName(mty.MultiSigX, signType))
+	if err != nil {
+		return tx, err
+	}
+
+	bytes, err := common.FromHex(hexPrivKey[:])
+	if err != nil {
+		return tx, err
+	}
+
+	privKey, err := c.PrivKeyFromBytes(bytes)
+	if err != nil {
+		return tx, err
+	}
+
+	tx.Sign(int32(signType), privKey)
+	return tx, nil
+}
+
+func multiSigAccCreate(parm *mty.MultiSigAccCreate) (*types.Transaction, error) {
+	if parm == nil {
+		return nil, types.ErrInvalidParam
+	}
+	multiSig := &mty.MultiSigAction{
+		Ty:    mty.ActionMultiSigAccCreate,
+		Value: &mty.MultiSigAction_MultiSigAccCreate{MultiSigAccCreate: parm},
+	}
+	return types.CreateFormatTx(types.ExecName(mty.MultiSigX), types.Encode(multiSig))
+}
+
+func multiSigOwnerOperate(parm *mty.MultiSigOwnerOperate) (*types.Transaction, error) {
+	if parm == nil {
+		return nil, types.ErrInvalidParam
+	}
+	multiSig := &mty.MultiSigAction{
+		Ty:    mty.ActionMultiSigOwnerOperate,
+		Value: &mty.MultiSigAction_MultiSigOwnerOperate{MultiSigOwnerOperate: parm},
+	}
+	return types.CreateFormatTx(types.ExecName(mty.MultiSigX), types.Encode(multiSig))
+}
+
+func multiSigAccOperate(parm *mty.MultiSigAccOperate) (*types.Transaction, error) {
+	if parm == nil {
+		return nil, types.ErrInvalidParam
+	}
+	multiSig := &mty.MultiSigAction{
+		Ty:    mty.ActionMultiSigAccOperate,
+		Value: &mty.MultiSigAction_MultiSigAccOperate{MultiSigAccOperate: parm},
+	}
+	return types.CreateFormatTx(types.ExecName(mty.MultiSigX), types.Encode(multiSig))
+}
+
+func multiSigConfirmTx(parm *mty.MultiSigConfirmTx) (*types.Transaction, error) {
+	if parm == nil {
+		return nil, types.ErrInvalidParam
+	}
+	multiSig := &mty.MultiSigAction{
+		Ty:    mty.ActionMultiSigConfirmTx,
+		Value: &mty.MultiSigAction_MultiSigConfirmTx{MultiSigConfirmTx: parm},
+	}
+	return types.CreateFormatTx(types.ExecName(mty.MultiSigX), types.Encode(multiSig))
+}
+func multiSigExecTransferTo(parm *mty.MultiSigExecTransferTo, fromOrTo bool) (*types.Transaction, error) {
+	if parm == nil {
+		return nil, types.ErrInvalidParam
+	}
+	multiSig := &mty.MultiSigAction{
+		Ty:    mty.ActionMultiSigExecTransferTo,
+		Value: &mty.MultiSigAction_MultiSigExecTransferTo{MultiSigExecTransferTo: parm},
+	}
+	return types.CreateFormatTx(types.ExecName(mty.MultiSigX), types.Encode(multiSig))
+}
+
+func multiSigExecTransferFrom(parm *mty.MultiSigExecTransferFrom, fromOrTo bool) (*types.Transaction, error) {
+	if parm == nil {
+		return nil, types.ErrInvalidParam
+	}
+	multiSig := &mty.MultiSigAction{
+		Ty:    mty.ActionMultiSigExecTransferFrom,
+		Value: &mty.MultiSigAction_MultiSigExecTransferFrom{MultiSigExecTransferFrom: parm},
+	}
+	return types.CreateFormatTx(types.ExecName(mty.MultiSigX), types.Encode(multiSig))
+}

plugin/dapp/multisig/executor/kv.go

+// Copyright Fuzamei Corp. 2018 All Rights Reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package executor
+
+import (
+	"fmt"
+)
+
+//数据库存储格式key
+const (
+	//MultiSigPrefix statedb中账户和交易的存储格式
+	MultiSigPrefix   = "mavl-multisig-"
+	MultiSigTxPrefix = "mavl-multisig-tx-"
+
+	//MultiSigLocalPrefix localdb中账户和交易的存储格式multisig account count记录账户个数
+	MultiSigLocalPrefix = "LODB-multisig-"
+	MultiSigAccCount    = "acccount"
+	MultiSigAcc         = "account"
+	MultiSigAllAcc      = "allacc"
+	MultiSigTx          = "tx"
+	MultiSigRecvAssets  = "assets"
+	MultiSigAccCreate   = "create"
+)
+
+//statedb中账户和交易的存储格式
+func calcMultiSigAccountKey(multiSigAccAddr string) (key []byte) {
+	return []byte(fmt.Sprintf(MultiSigPrefix+"%s", multiSigAccAddr))
+}
+
+//存储格式："mavl-multisig-tx-accaddr-000000000000"
+func calcMultiSigAccTxKey(multiSigAccAddr string, txid uint64) (key []byte) {
+	txstr := fmt.Sprintf("%018d", txid)
+	return []byte(fmt.Sprintf(MultiSigTxPrefix+"%s-%s", multiSigAccAddr, txstr))
+}
+
+//localdb中账户相关的存储格式
+
+//记录创建的账户数量，key:Msac value：count。
+func calcMultiSigAccCountKey() []byte {
+	return []byte(fmt.Sprintf(MultiSigLocalPrefix+"%s", MultiSigAccCount))
+}
+
+//存储所有的MultiSig账户地址：按顺序存储方便以后分页查找: key:Ms:allacc:index,value:accaddr
+func calcMultiSigAllAcc(accindex int64) (key []byte) {
+	accstr := fmt.Sprintf("%018d", accindex)
+	return []byte(fmt.Sprintf(MultiSigLocalPrefix+"%s-%s", MultiSigAllAcc, accstr))
+}
+
+//记录指定账号地址的信息value：MultiSig。key:Ms:acc
+func calcMultiSigAcc(addr string) (key []byte) {
+	return []byte(fmt.Sprintf(MultiSigLocalPrefix+"%s-%s", MultiSigAcc, addr))
+}
+
+//记录某个地址创建的所有多重签名账户。key:Ms:create:createAddr，value：[]string。
+func calcMultiSigAccCreateAddr(createAddr string) (key []byte) {
+	return []byte(fmt.Sprintf(MultiSigLocalPrefix+"%s:-%s", MultiSigAccCreate, createAddr))
+}
+
+//localdb中账户相关的存储格式
+
+//记录指定账号地址的信息key:Ms:tx:addr:txid  value：MultiSigTx。
+func calcMultiSigAccTx(addr string, txid uint64) (key []byte) {
+	accstr := fmt.Sprintf("%018d", txid)
+
+	return []byte(fmt.Sprintf(MultiSigLocalPrefix+"%s-%s-%s", MultiSigTx, addr, accstr))
+}
+
+//可以通过前缀查找获取指定账户上收到的所有资产数量
+//MultiSig合约中账户收到指定资产的计数key:Ms:assets:addr:execname:symbol  value：AccountAssets。
+//message AccountAssets {
+//	string multiSigAddr = 1;
+//	string execer 		= 2;
+//	string symbol 		= 3;
+//	int64  amount 		= 4;
+func calcAddrRecvAmountKey(addr, execname, symbol string) []byte {
+	return []byte(fmt.Sprintf(MultiSigLocalPrefix+"%s-%s-%s-%s", MultiSigRecvAssets, addr, execname, symbol))
+}
+
+// 前缀查找某个账户下的所有资产信息
+func calcAddrRecvAmountPrefix(addr string) []byte {
+	return []byte(fmt.Sprintf(MultiSigLocalPrefix+"%s-%s-", MultiSigRecvAssets, addr))
+}

plugin/dapp/multisig/executor/multisig.go

+// Copyright Fuzamei Corp. 2018 All Rights Reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package executor
+
+/*
+multiSig合约主要实现如下功能：
+//创建多重签名账户
+//多重签名账户owner属性的修改：owner的add/del/replace等
+//多重签名账户属性的修改：weight权重以及每日限额的修改
+//多重签名账户交易的确认和撤销
+//合约中外部账户转账到多重签名账户，Addr --->multiSigAddr
+//合约中多重签名账户转账到外部账户，multiSigAddr--->Addr
+*/
+
+import (
+	"bytes"
+	"encoding/hex"
+
+	"github.com/33cn/chain33/account"
+	"github.com/33cn/chain33/client"
+	"github.com/33cn/chain33/common/address"
+	log "github.com/33cn/chain33/common/log/log15"
+	"github.com/33cn/chain33/system/dapp"
+	drivers "github.com/33cn/chain33/system/dapp"
+	"github.com/33cn/chain33/types"
+	mty "github.com/33cn/plugin/plugin/dapp/multisig/types"
+)
+
+var multisiglog = log.New("module", "execs.multisig")
+
+var driverName = "multisig"
+
+func init() {
+	ety := types.LoadExecutorType(driverName)
+	ety.InitFuncList(types.ListMethod(&MultiSig{}))
+}
+
+// Init multisig模块初始化
+func Init(name string, sub []byte) {
+	drivers.Register(GetName(), newMultiSig, types.GetDappFork(driverName, "Enable"))
+}
+
+// GetName multisig合约name
+func GetName() string {
+	return newMultiSig().GetName()
+}
+
+// MultiSig multisig合约实例
+type MultiSig struct {
+	drivers.DriverBase
+}
+
+func newMultiSig() drivers.Driver {
+	m := &MultiSig{}
+	m.SetChild(m)
+	m.SetExecutorType(types.LoadExecutorType(driverName))
+	return m
+}
+
+// GetDriverName 获取multisig合约name
+func (m *MultiSig) GetDriverName() string {
+	return driverName
+}
+
+// CheckTx 检测multisig合约交易,转账交易amount不能为负数
+func (m *MultiSig) CheckTx(tx *types.Transaction, index int) error {
+	ety := m.GetExecutorType()
+
+	//amount check
+	amount, err := ety.Amount(tx)
+	if err != nil {
+		return err
+	}
+	if amount < 0 {
+		return types.ErrAmount
+	}
+
+	_, v, err := ety.DecodePayloadValue(tx)
+	if err != nil {
+		return err
+	}
+	payload := v.Interface()
+
+	//MultiSigAccCreate 交易校验
+	if ato, ok := payload.(*mty.MultiSigAccCreate); ok {
+		return checkAccountCreateTx(ato)
+	}
+
+	//MultiSigOwnerOperate 交易的检测
+	if ato, ok := payload.(*mty.MultiSigOwnerOperate); ok {
+		return checkOwnerOperateTx(ato)
+	}
+	//MultiSigAccOperate 交易的检测
+	if ato, ok := payload.(*mty.MultiSigAccOperate); ok {
+		return checkAccountOperateTx(ato)
+	}
+	//MultiSigConfirmTx  交易的检测
+	if ato, ok := payload.(*mty.MultiSigConfirmTx); ok {
+		if err := address.CheckMultiSignAddress(ato.GetMultiSigAccAddr()); err != nil {
+			return types.ErrInvalidAddress
+		}
+		return nil
+	}
+
+	//MultiSigExecTransferTo 交易的检测
+	if ato, ok := payload.(*mty.MultiSigExecTransferTo); ok {
+		if err := address.CheckMultiSignAddress(ato.GetTo()); err != nil {
+			return types.ErrInvalidAddress
+		}
+		//assets check
+		return mty.IsAssetsInvalid(ato.GetExecname(), ato.GetSymbol())
+	}
+	//MultiSigExecTransferFrom 交易的检测
+	if ato, ok := payload.(*mty.MultiSigExecTransferFrom); ok {
+		//from addr check
+		if err := address.CheckMultiSignAddress(ato.GetFrom()); err != nil {
+			return types.ErrInvalidAddress
+		}
+		//to addr check
+		if err := address.CheckAddress(ato.GetTo()); err != nil {
+			return types.ErrInvalidAddress
+		}
+		//assets check
+		return mty.IsAssetsInvalid(ato.GetExecname(), ato.GetSymbol())
+	}
+
+	return nil
+}
+func checkAccountCreateTx(ato *mty.MultiSigAccCreate) error {
+	var totalweight uint64
+	var ownerCount int
+
+	requiredWeight := ato.GetRequiredWeight()
+	if requiredWeight == 0 {
+		return mty.ErrInvalidWeight
+	}
+	owners := ato.GetOwners()
+	ownersMap := make(map[string]bool)
+
+	//创建时requiredweight权重的值不能大于所有owner权重之和
+	for _, owner := range owners {
+		if owner != nil {
+			if err := address.CheckAddress(owner.OwnerAddr); err != nil {
+				return types.ErrInvalidAddress
+			}
+			if owner.Weight == 0 {
+				return mty.ErrInvalidWeight
+			}
+			if ownersMap[owner.OwnerAddr] {
+				return mty.ErrOwnerExist
+			}
+			ownersMap[owner.OwnerAddr] = true
+			totalweight += owner.Weight
+			ownerCount = ownerCount + 1
+		}
+	}
+
+	if ato.RequiredWeight > totalweight {
+		return mty.ErrRequiredweight
+	}
+
+	//创建时最少设置两个owner
+	if ownerCount < mty.MinOwnersInit {
+		return mty.ErrOwnerLessThanTwo
+	}
+	//owner总数不能大于最大值
+	if ownerCount > mty.MaxOwnersCount {
+		return mty.ErrMaxOwnerCount
+	}
+
+	dailyLimit := ato.GetDailyLimit()
+	//assets check
+	return mty.IsAssetsInvalid(dailyLimit.GetExecer(), dailyLimit.GetSymbol())
+}
+
+func checkOwnerOperateTx(ato *mty.MultiSigOwnerOperate) error {
+	OldOwner := ato.GetOldOwner()
+	NewOwner := ato.GetNewOwner()
+	NewWeight := ato.GetNewWeight()
+	MultiSigAccAddr := ato.GetMultiSigAccAddr()
+	if err := address.CheckMultiSignAddress(MultiSigAccAddr); err != nil {
+		return types.ErrInvalidAddress
+	}
+
+	if ato.OperateFlag == mty.OwnerAdd {
+		if err := address.CheckAddress(NewOwner); err != nil {
+			return types.ErrInvalidAddress
+		}
+		if NewWeight <= 0 {
+			return mty.ErrInvalidWeight
+		}
+	}
+	if ato.OperateFlag == mty.OwnerDel {
+		if err := address.CheckAddress(OldOwner); err != nil {
+			return types.ErrInvalidAddress
+		}
+	}
+	if ato.OperateFlag == mty.OwnerModify {
+		if err := address.CheckAddress(OldOwner); err != nil {
+			return types.ErrInvalidAddress
+		}
+		if NewWeight <= 0 {
+			return mty.ErrInvalidWeight
+		}
+	}
+	if ato.OperateFlag == mty.OwnerReplace {
+		if err := address.CheckAddress(OldOwner); err != nil {
+			return types.ErrInvalidAddress
+		}
+		if err := address.CheckAddress(NewOwner); err != nil {
+			return types.ErrInvalidAddress
+		}
+	}
+	return nil
+}
+func checkAccountOperateTx(ato *mty.MultiSigAccOperate) error {
+	//MultiSigAccOperate MultiSigAccAddr 地址检测
+	MultiSigAccAddr := ato.GetMultiSigAccAddr()
+	if err := address.CheckMultiSignAddress(MultiSigAccAddr); err != nil {
+		return types.ErrInvalidAddress
+	}
+
+	if ato.OperateFlag == mty.AccWeightOp {
+		NewWeight := ato.GetNewRequiredWeight()
+		if NewWeight <= 0 {
+			return mty.ErrInvalidWeight
+		}
+	}
+	if ato.OperateFlag == mty.AccDailyLimitOp {
+		dailyLimit := ato.GetDailyLimit()
+		//assets check
+		return mty.IsAssetsInvalid(dailyLimit.GetExecer(), dailyLimit.GetSymbol())
+	}
+	return nil
+}
+
+//多重签名交易的Receipt处理
+func (m *MultiSig) execLocalMultiSigReceipt(receiptData *types.ReceiptData, tx *types.Transaction, addOrRollback bool) ([]*types.KeyValue, error) {
+	var set []*types.KeyValue
+	for _, log := range receiptData.Logs {
+		multisiglog.Info("execLocalMultiSigReceipt", "Ty", log.Ty)
+
+		switch log.Ty {
+		case mty.TyLogMultiSigAccCreate:
+			{
+				var receipt mty.MultiSig
+				err := types.Decode(log.Log, &receipt)
+				if err != nil {
+					return nil, err
+				}
+
+				kv, err := m.saveMultiSigAccCreate(&receipt, addOrRollback)
+				if err != nil {
+					return nil, err
+				}
+				set = append(set, kv...)
+			}
+		case mty.TyLogMultiSigOwnerAdd,
+			mty.TyLogMultiSigOwnerDel:
+			{
+				var receipt mty.ReceiptOwnerAddOrDel
+				err := types.Decode(log.Log, &receipt)
+				if err != nil {
+					return nil, err
+				}
+				kv, err := m.saveMultiSigOwnerAddOrDel(receipt, addOrRollback)
+				if err != nil {
+					return nil, err
+				}
+				set = append(set, kv...)
+			}
+		case mty.TyLogMultiSigOwnerModify,
+			mty.TyLogMultiSigOwnerReplace:
+			{
+				var receipt mty.ReceiptOwnerModOrRep
+				err := types.Decode(log.Log, &receipt)
+				if err != nil {
+					return nil, err
+				}
+				kv, err := m.saveMultiSigOwnerModOrRep(receipt, addOrRollback)
+				if err != nil {
+					return nil, err
+				}
+				set = append(set, kv...)
+			}
+		case mty.TyLogMultiSigAccWeightModify:
+			{
+				var receipt mty.ReceiptWeightModify
+				err := types.Decode(log.Log, &receipt)
+				if err != nil {
+					return nil, err
+				}
+				kv, err := m.saveMultiSigAccWeight(receipt, addOrRollback)
+				if err != nil {
+					return nil, err
+				}
+				set = append(set, kv...)
+			}
+		case mty.TyLogMultiSigAccDailyLimitAdd,
+			mty.TyLogMultiSigAccDailyLimitModify:
+			{
+				var receipt mty.ReceiptDailyLimitOperate
+				err := types.Decode(log.Log, &receipt)
+				if err != nil {
+					return nil, err
+				}
+				kv, err := m.saveMultiSigAccDailyLimit(receipt, addOrRollback)
+				if err != nil {
+					return nil, err
+				}
+				set = append(set, kv...)
+			}
+		case mty.TyLogMultiSigConfirmTx, //只是交易确认和撤销，交易没有被执行
+			mty.TyLogMultiSigConfirmTxRevoke:
+			{
+				var receipt mty.ReceiptConfirmTx
+				err := types.Decode(log.Log, &receipt)
+				if err != nil {
+					return nil, err
+				}
+				kv, err := m.saveMultiSigConfirmTx(receipt, addOrRollback)
+				if err != nil {
+					return nil, err
+				}
+				set = append(set, kv...)
+			}
+		case mty.TyLogDailyLimitUpdate: //账户的DailyLimit更新
+			{
+				var receipt mty.ReceiptAccDailyLimitUpdate
+				err := types.Decode(log.Log, &receipt)
+				if err != nil {
+					return nil, err
+				}
+				kv, err := m.saveDailyLimitUpdate(receipt, addOrRollback)
+				if err != nil {
+					return nil, err
+				}
+				set = append(set, kv...)
+			}
+		case mty.TyLogMultiSigTx: //交易被某个owner确认并执行
+			{
+				var receipt mty.ReceiptMultiSigTx
+				err := types.Decode(log.Log, &receipt)
+				if err != nil {
+					return nil, err
+				}
+				//交易被执行需要更新tx的执行状态以及确认owner列表
+				kv1, err := m.saveMultiSigTx(receipt, addOrRollback)
+				if err != nil {
+					return nil, err
+				}
+				set = append(set, kv1...)
+
+				//转账交易被执行需要更新账户的amount统计计数,需要区分submit和confirm
+				if receipt.CurExecuted {
+					kv2, err := m.saveMultiSigTransfer(tx, receipt.SubmitOrConfirm, addOrRollback)
+					if err != nil {
+						return nil, err
+					}
+					set = append(set, kv2...)
+				}
+			}
+		case mty.TyLogTxCountUpdate:
+			{
+				var receipt mty.ReceiptTxCountUpdate
+				err := types.Decode(log.Log, &receipt)
+				if err != nil {
+					return nil, err
+				}
+				kv, err := m.saveMultiSigTxCountUpdate(receipt, addOrRollback)
+				if err != nil {
+					return nil, err
+				}
+				set = append(set, kv...)
+			}
+		default:
+			break
+		}
+	}
+	return set, nil
+}
+
+//转账交易to地址收币数量更新，Submit直接解析tx。Confirm需要解析对应txid的交易信息
+func (m *MultiSig) saveMultiSigTransfer(tx *types.Transaction, SubmitOrConfirm, addOrRollback bool) ([]*types.KeyValue, error) {
+	var set []*types.KeyValue
+	//执行成功解析GetPayload信息
+	var action mty.MultiSigAction
+	err := types.Decode(tx.GetPayload(), &action)
+	if err != nil {
+		panic(err)
+	}
+	var to string
+	var execname string
+	var symbol string
+	var amount int64
+
+	//addr-->multiSigAccAddr
+	//multiSigAccAddr-->addr
+	if SubmitOrConfirm {
+		if action.Ty == mty.ActionMultiSigExecTransferTo && action.GetMultiSigExecTransferTo() != nil {
+			tx := action.GetMultiSigExecTransferTo()
+			to = tx.To
+			execname = tx.Execname
+			symbol = tx.Symbol
+			amount = tx.Amount
+		} else if action.Ty == mty.ActionMultiSigExecTransferFrom && action.GetMultiSigExecTransferFrom() != nil {
+			tx := action.GetMultiSigExecTransferFrom()
+			to = tx.To
+			execname = tx.Execname
+			symbol = tx.Symbol
+			amount = tx.Amount
+		} else {
+			return set, nil
+		}
+	} else {
+		if action.Ty != mty.ActionMultiSigConfirmTx || action.GetMultiSigConfirmTx() == nil {
+			return nil, mty.ErrActionTyNoMatch
+		}
+		//通过需要确认的txid从数据库中获取对应的multiSigTx信息，然后根据txhash查询具体的交易详情
+		multiSigConfirmTx := action.GetMultiSigConfirmTx()
+		multiSigTx, err := getMultiSigTx(m.GetLocalDB(), multiSigConfirmTx.MultiSigAccAddr, multiSigConfirmTx.TxId)
+		if err != nil {
+			return set, err
+		}
+		tx, err := getTxByHash(m.GetAPI(), multiSigTx.TxHash)
+		if err != nil {
+			return nil, err
+		}
+		payload, err := getMultiSigTxPayload(tx)
+		if err != nil {
+			return nil, err
+		}
+		if multiSigTx.TxType == mty.TransferOperate {
+			tx := payload.GetMultiSigExecTransferFrom()
+			to = tx.To
+			execname = tx.Execname
+			symbol = tx.Symbol
+			amount = tx.Amount
+		} else {
+			return set, nil
+		}
+	}
+	kv, err := updateAddrReciver(m.GetLocalDB(), to, execname, symbol, amount, addOrRollback)
+	if err != nil {
+		return set, err
+	}
+	if kv != nil {
+		set = append(set, kv)
+	}
+	return set, nil
+}
+
+//localdb Receipt相关消息的处理。需要区分执行的是add/Rollback
+func (m *MultiSig) saveMultiSigAccCreate(multiSig *mty.MultiSig, addOrRollback bool) ([]*types.KeyValue, error) {
+	multiSigAddr := multiSig.MultiSigAddr
+	//增加一个多重签名账户信息到localdb中，第一次增加时账户在local中应该是不存在的。如果存在就返回错误
+	oldmultiSig, err := getMultiSigAccount(m.GetLocalDB(), multiSigAddr)
+	if err != nil {
+		return nil, err
+	}
+	if addOrRollback && oldmultiSig != nil { //创建的账户已经存在报错
+		multisiglog.Error("saveMultiSigAccCreate:getMultiSigAccount", "addOrRollback", addOrRollback, "MultiSigAddr", multiSigAddr, "oldmultiSig", oldmultiSig, "err", err)
+		return nil, mty.ErrAccountHasExist
+
+	} else if !addOrRollback && oldmultiSig == nil { //回滚函数的账户不经存在报错
+		multisiglog.Error("saveMultiSigAccCreate:getMultiSigAccount", "addOrRollback", addOrRollback, "MultiSigAddr", multiSigAddr, "err", err)
+		return nil, types.ErrAccountNotExist
+	}
+
+	err = setMultiSigAccount(m.GetLocalDB(), multiSig, addOrRollback)
+	if err != nil {
+		return nil, err
+	}
+	accountkv := getMultiSigAccountKV(multiSig, addOrRollback)
+
+	//获取当前的账户计数
+	lastcount, err := getMultiSigAccCount(m.GetLocalDB())
+	if err != nil {
+		return nil, err
+	}
+
+	//更新账户列表,回滚时索引需要--
+	if !addOrRollback && lastcount > 0 {
+		lastcount = lastcount - 1
+	}
+	accCountListkv, err := updateMultiSigAccList(m.GetLocalDB(), multiSig.MultiSigAddr, lastcount, addOrRollback)
+	if err != nil {
+		return nil, err
+	}
+
+	//账户计数增加一个
+	accCountkv, err := updateMultiSigAccCount(m.GetLocalDB(), addOrRollback)
+	if err != nil {
+		return nil, err
+	}
+	//更新create地址创建的多重签名账户
+	accAddrkv := setMultiSigAddress(m.GetLocalDB(), multiSig.CreateAddr, multiSig.MultiSigAddr, addOrRollback)
+
+	var kvs []*types.KeyValue
+	kvs = append(kvs, accCountkv)
+	kvs = append(kvs, accountkv)
+	kvs = append(kvs, accCountListkv)
+	kvs = append(kvs, accAddrkv)
+
+	return kvs, nil
+}
+
+//账户owner的add/del操作.需要区分add/del 交易
+func (m *MultiSig) saveMultiSigOwnerAddOrDel(ownerOp mty.ReceiptOwnerAddOrDel, addOrRollback bool) ([]*types.KeyValue, error) {
+	//增加一个多重签名账户信息到localdb中，第一次增加时账户在local中应该是不存在的。如果存在就返回错误
+	multiSig, err := getMultiSigAccount(m.GetLocalDB(), ownerOp.MultiSigAddr)
+	multisiglog.Error("saveMultiSigOwnerAddOrDel", "ownerOp", ownerOp)
+
+	if err != nil || multiSig == nil {
+		multisiglog.Error("saveMultiSigOwnerAddOrDel", "addOrRollback", addOrRollback, "ownerOp", ownerOp, "err", err)
+		return nil, err
+	}
+	multisiglog.Error("saveMultiSigOwnerAddOrDel", "wonerlen ", len(multiSig.Owners))
+
+	_, index, _, _, find := getOwnerInfoByAddr(multiSig, ownerOp.Owner.OwnerAddr)
+	if addOrRollback { //正常添加交易
+		if ownerOp.AddOrDel && !find { //add owner
+			multiSig.Owners = append(multiSig.Owners, ownerOp.Owner)
+		} else if !ownerOp.AddOrDel && find { //dell owner
+			multiSig.Owners = delOwner(multiSig.Owners, index)
+			//multiSig.Owners = append(multiSig.Owners[0:index], multiSig.Owners[index+1:]...)
+		} else {
+			multisiglog.Error("saveMultiSigOwnerAddOrDel", "addOrRollback", addOrRollback, "ownerOp", ownerOp, "index", index, "find", find)
+			return nil, mty.ErrOwnerNoMatch
+		}
+
+	} else { //回滚删除交易
+		if ownerOp.AddOrDel && find { //回滚add owner
+			multiSig.Owners = delOwner(multiSig.Owners, index)
+			//multiSig.Owners = append(multiSig.Owners[0:index], multiSig.Owners[index+1:]...)
+		} else if !ownerOp.AddOrDel && !find { //回滚 del owner
+			multiSig.Owners = append(multiSig.Owners, ownerOp.Owner)
+		} else {
+			multisiglog.Error("saveMultiSigOwnerAddOrDel", "addOrRollback", addOrRollback, "ownerOp", ownerOp, "index", index, "find", find)
+			return nil, mty.ErrOwnerNoMatch
+		}
+	}
+	multisiglog.Error("saveMultiSigOwnerAddOrDel", "addOrRollback", addOrRollback, "ownerOp", ownerOp, "multiSig", multiSig)
+
+	err = setMultiSigAccount(m.GetLocalDB(), multiSig, true)
+	if err != nil {
+		return nil, err
+	}
+	accountkv := getMultiSigAccountKV(multiSig, true)
+
+	var kvs []*types.KeyValue
+	kvs = append(kvs, accountkv)
+	return kvs, nil
+}
+
+//账户owner的mod/replace操作
+func (m *MultiSig) saveMultiSigOwnerModOrRep(ownerOp mty.ReceiptOwnerModOrRep, addOrRollback bool) ([]*types.KeyValue, error) {
+	//获取多重签名账户信息从db中
+	multiSig, err := getMultiSigAccount(m.GetLocalDB(), ownerOp.MultiSigAddr)
+
+	if err != nil || multiSig == nil {
+		return nil, err
+	}
+	if addOrRollback { //正常添加交易
+		_, index, _, _, find := getOwnerInfoByAddr(multiSig, ownerOp.PrevOwner.OwnerAddr)
+		if ownerOp.ModOrRep && find { //modify owner weight
+			multiSig.Owners[index].Weight = ownerOp.CurrentOwner.Weight
+		} else if !ownerOp.ModOrRep && find { //replace owner addr
+			multiSig.Owners[index].OwnerAddr = ownerOp.CurrentOwner.OwnerAddr
+		} else {
+			multisiglog.Error("saveMultiSigOwnerModOrRep ", "addOrRollback", addOrRollback, "ownerOp", ownerOp, "index", index, "find", find)
+			return nil, mty.ErrOwnerNoMatch
+		}
+
+	} else { //回滚删除交易
+		_, index, _, _, find := getOwnerInfoByAddr(multiSig, ownerOp.CurrentOwner.OwnerAddr)
+		if ownerOp.ModOrRep && find { //回滚modify owner weight
+			multiSig.Owners[index].Weight = ownerOp.PrevOwner.Weight
+		} else if !ownerOp.ModOrRep && find { //回滚 replace owner addr
+			multiSig.Owners[index].OwnerAddr = ownerOp.PrevOwner.OwnerAddr
+		} else {
+			multisiglog.Error("saveMultiSigOwnerModOrRep ", "addOrRollback", addOrRollback, "ownerOp", ownerOp, "index", index, "find", find)
+			return nil, mty.ErrOwnerNoMatch
+		}
+	}
+
+	err = setMultiSigAccount(m.GetLocalDB(), multiSig, true)
+	if err != nil {
+		return nil, err
+	}
+	accountkv := getMultiSigAccountKV(multiSig, true)
+
+	var kvs []*types.KeyValue
+	kvs = append(kvs, accountkv)
+	return kvs, nil
+}
+
+//账户weight权重的mod操作
+func (m *MultiSig) saveMultiSigAccWeight(accountOp mty.ReceiptWeightModify, addOrRollback bool) ([]*types.KeyValue, error) {
+	//获取多重签名账户信息从db中
+	multiSig, err := getMultiSigAccount(m.GetLocalDB(), accountOp.MultiSigAddr)
+
+	if err != nil || multiSig == nil {
+		return nil, err
+	}
+	if addOrRollback { //正常添加交易
+		multiSig.RequiredWeight = accountOp.CurrentWeight
+	} else { //回滚删除交易
+		multiSig.RequiredWeight = accountOp.PrevWeight
+	}
+
+	err = setMultiSigAccount(m.GetLocalDB(), multiSig, true)
+	if err != nil {
+		return nil, err
+	}
+	accountkv := getMultiSigAccountKV(multiSig, true)
+
+	var kvs []*types.KeyValue
+	kvs = append(kvs, accountkv)
+	return kvs, nil
+}
+
+//账户DailyLimit资产每日限额的add/mod操作
+func (m *MultiSig) saveMultiSigAccDailyLimit(accountOp mty.ReceiptDailyLimitOperate, addOrRollback bool) ([]*types.KeyValue, error) {
+	//获取多重签名账户信息从db中
+	multiSig, err := getMultiSigAccount(m.GetLocalDB(), accountOp.MultiSigAddr)
+
+	if err != nil || multiSig == nil {
+		return nil, err
+	}
+	curExecer := accountOp.CurDailyLimit.Execer
+	curSymbol := accountOp.CurDailyLimit.Symbol
+	curDailyLimit := accountOp.CurDailyLimit
+	prevDailyLimit := accountOp.PrevDailyLimit
+
+	//在每日限额列表中查找具体资产的每日限额信息
+	index, find := isDailyLimit(multiSig, curExecer, curSymbol)
+
+	if addOrRollback { //正常添加交易
+		if accountOp.AddOrModify && !find { //add DailyLimit
+			multiSig.DailyLimits = append(multiSig.DailyLimits, curDailyLimit)
+		} else if !accountOp.AddOrModify && find { //modifyDailyLimit
+			multiSig.DailyLimits[index].DailyLimit = curDailyLimit.DailyLimit
+			multiSig.DailyLimits[index].SpentToday = curDailyLimit.SpentToday
+			multiSig.DailyLimits[index].LastDay = curDailyLimit.LastDay
+		} else {
+			multisiglog.Error("saveMultiSigAccDailyLimit", "addOrRollback", addOrRollback, "accountOp", accountOp, "index", index, "find", find)
+			return nil, mty.ErrDailyLimitNoMatch
+		}
+	} else { //回滚删除交易
+		if accountOp.AddOrModify && find { //删除已经 add 的 DailyLimit
+			multiSig.DailyLimits = append(multiSig.DailyLimits[0:index], multiSig.DailyLimits[index+1:]...)
+		} else if !accountOp.AddOrModify && find { //恢复前一次的状态 modifyDailyLimit
+			multiSig.DailyLimits[index].DailyLimit = prevDailyLimit.DailyLimit
+			multiSig.DailyLimits[index].SpentToday = prevDailyLimit.SpentToday
+			multiSig.DailyLimits[index].LastDay = prevDailyLimit.LastDay
+		} else {
+			multisiglog.Error("saveMultiSigAccDailyLimit", "addOrRollback", addOrRollback, "accountOp", accountOp, "index", index, "find", find)
+			return nil, mty.ErrDailyLimitNoMatch
+		}
+	}
+
+	err = setMultiSigAccount(m.GetLocalDB(), multiSig, true)
+	if err != nil {
+		return nil, err
+	}
+	accountkv := getMultiSigAccountKV(multiSig, true)
+
+	var kvs []*types.KeyValue
+	kvs = append(kvs, accountkv)
+	return kvs, nil
+}
+
+//多重签名账户交易的Confirm/Revoke
+func (m *MultiSig) saveMultiSigConfirmTx(confirmTx mty.ReceiptConfirmTx, addOrRollback bool) ([]*types.KeyValue, error) {
+	multiSigAddr := confirmTx.MultiSigTxOwner.MultiSigAddr
+	txid := confirmTx.MultiSigTxOwner.Txid
+	owner := confirmTx.MultiSigTxOwner.ConfirmedOwner
+
+	//获取多重签名交易信息从db中
+	multiSigTx, err := getMultiSigTx(m.GetLocalDB(), multiSigAddr, txid)
+	if err != nil {
+		return nil, err
+	}
+	if multiSigTx == nil {
+		multisiglog.Error("saveMultiSigConfirmTx", "addOrRollback", addOrRollback, "confirmTx", confirmTx)
+		return nil, mty.ErrTxidNotExist
+	}
+	index, exist := isOwnerConfirmedTx(multiSigTx, owner.OwnerAddr)
+	if addOrRollback { //正常添加交易
+		if confirmTx.ConfirmeOrRevoke && !exist { //add Confirmed Owner
+			multiSigTx.ConfirmedOwner = append(multiSigTx.ConfirmedOwner, owner)
+		} else if !confirmTx.ConfirmeOrRevoke && exist { //Revoke Confirmed Owner
+			multiSigTx.ConfirmedOwner = append(multiSigTx.ConfirmedOwner[0:index], multiSigTx.ConfirmedOwner[index+1:]...)
+		} else {
+			multisiglog.Error("saveMultiSigConfirmTx", "addOrRollback", addOrRollback, "confirmTx", confirmTx, "index", index, "exist", exist)
+			return nil, mty.ErrDailyLimitNoMatch
+		}
+	} else { //回滚删除交易
+		if confirmTx.ConfirmeOrRevoke && exist { //回滚已经 add Confirmed Owner
+			//multiSigTx.ConfirmedOwner = append(multiSigTx.ConfirmedOwner, owner)
+			multiSigTx.ConfirmedOwner = append(multiSigTx.ConfirmedOwner[0:index], multiSigTx.ConfirmedOwner[index+1:]...)
+
+		} else if !confirmTx.ConfirmeOrRevoke && !exist { //回滚已经 Revoke Confirmed Owner
+			multiSigTx.ConfirmedOwner = append(multiSigTx.ConfirmedOwner, owner)
+		} else {
+			multisiglog.Error("saveMultiSigConfirmTx", "addOrRollback", addOrRollback, "confirmTx", confirmTx, "index", index, "exist", exist)
+			return nil, mty.ErrDailyLimitNoMatch
+		}
+	}
+
+	err = setMultiSigTx(m.GetLocalDB(), multiSigTx, true)
+	if err != nil {
+		return nil, err
+	}
+	txkv := getMultiSigTxKV(multiSigTx, true)
+
+	var kvs []*types.KeyValue
+	kvs = append(kvs, txkv)
+	return kvs, nil
+}
+
+//多重签名账户交易被确认执行,更新交易的执行结果以及增加确认owner
+//包含转账的交易以及修改多重签名账户属性的交易
+func (m *MultiSig) saveMultiSigTx(execTx mty.ReceiptMultiSigTx, addOrRollback bool) ([]*types.KeyValue, error) {
+	multiSigAddr := execTx.MultiSigTxOwner.MultiSigAddr
+	txid := execTx.MultiSigTxOwner.Txid
+	owner := execTx.MultiSigTxOwner.ConfirmedOwner
+	curExecuted := execTx.CurExecuted
+	prevExecuted := execTx.PrevExecuted
+	submitOrConfirm := execTx.SubmitOrConfirm
+
+	temMultiSigTx := &mty.MultiSigTx{}
+	temMultiSigTx.MultiSigAddr = multiSigAddr
+	temMultiSigTx.Txid = txid
+	temMultiSigTx.TxHash = execTx.TxHash
+	temMultiSigTx.TxType = execTx.TxType
+	temMultiSigTx.Executed = false
+	//获取多重签名交易信息从db中
+	multiSigTx, err := getMultiSigTx(m.GetLocalDB(), multiSigAddr, txid)
+	if err != nil {
+		multisiglog.Error("saveMultiSigTx getMultiSigTx ", "addOrRollback", addOrRollback, "execTx", execTx, "err", err)
+		return nil, err
+	}
+
+	//Confirm的交易需要确认对应的txid已经存在
+	if multiSigTx == nil && !submitOrConfirm {
+		multisiglog.Error("saveMultiSigTx", "addOrRollback", addOrRollback, "execTx", execTx)
+		return nil, mty.ErrTxidNotExist
+	}
+
+	//add submit的交易需要创建txid，
+	if submitOrConfirm && addOrRollback {
+		if multiSigTx != nil {
+			multisiglog.Error("saveMultiSigTx", "addOrRollback", addOrRollback, "execTx", execTx)
+			return nil, mty.ErrTxidHasExist
+		}
+		multiSigTx = temMultiSigTx
+	}
+
+	index, exist := isOwnerConfirmedTx(multiSigTx, owner.OwnerAddr)
+	if addOrRollback { //正常添加交易
+		if !exist { //add Confirmed Owner and modify Executed
+			multiSigTx.ConfirmedOwner = append(multiSigTx.ConfirmedOwner, owner)
+			if prevExecuted != multiSigTx.Executed {
+				return nil, mty.ErrExecutedNoMatch
+			}
+			multiSigTx.Executed = curExecuted
+		} else {
+			multisiglog.Error("saveMultiSigTx", "addOrRollback", addOrRollback, "execTx", execTx, "index", index, "exist", exist)
+			return nil, mty.ErrOwnerNoMatch
+		}
+	} else { //回滚删除交易
+		if exist { //回滚已经 add Confirmed Owner and modify Executed
+			multiSigTx.ConfirmedOwner = append(multiSigTx.ConfirmedOwner[0:index], multiSigTx.ConfirmedOwner[index+1:]...)
+			multiSigTx.Executed = prevExecuted
+		} else {
+			multisiglog.Error("saveMultiSigTx", "addOrRollback", addOrRollback, "execTx", execTx, "index", index, "exist", exist)
+			return nil, mty.ErrOwnerNoMatch
+		}
+	}
+	//submit交易的回滚需要将对应txid的值设置成nil
+	setNil := true
+	if !addOrRollback && submitOrConfirm {
+		setNil = false
+	}
+
+	err = setMultiSigTx(m.GetLocalDB(), multiSigTx, setNil)
+	if err != nil {
+		return nil, err
+	}
+	txkv := getMultiSigTxKV(multiSigTx, setNil)
+
+	var kvs []*types.KeyValue
+	kvs = append(kvs, txkv)
+	return kvs, nil
+}
+
+//多重签名账户交易被确认执行，更新对应资产的每日限额信息，以及txcount计数
+func (m *MultiSig) saveDailyLimitUpdate(execTransfer mty.ReceiptAccDailyLimitUpdate, addOrRollback bool) ([]*types.KeyValue, error) {
+	multiSigAddr := execTransfer.MultiSigAddr
+	curDailyLimit := execTransfer.CurDailyLimit
+	prevDailyLimit := execTransfer.PrevDailyLimit
+	execer := execTransfer.CurDailyLimit.Execer
+	symbol := execTransfer.CurDailyLimit.Symbol
+
+	//获取多重签名交易信息从db中
+	multiSig, err := getMultiSigAccount(m.GetLocalDB(), multiSigAddr)
+	if err != nil {
+		return nil, err
+	}
+	if multiSig == nil {
+		multisiglog.Error("saveAccExecTransfer", "addOrRollback", addOrRollback, "execTransfer", execTransfer)
+		return nil, types.ErrAccountNotExist
+	}
+	index, exist := isDailyLimit(multiSig, execer, symbol)
+	if !exist {
+		return nil, types.ErrAccountNotExist
+	}
+	if addOrRollback { //正常添加交易
+		multiSig.DailyLimits[index].SpentToday = curDailyLimit.SpentToday
+		multiSig.DailyLimits[index].LastDay = curDailyLimit.LastDay
+	} else { //回滚删除交易
+		multiSig.DailyLimits[index].SpentToday = prevDailyLimit.SpentToday
+		multiSig.DailyLimits[index].LastDay = prevDailyLimit.LastDay
+	}
+
+	err = setMultiSigAccount(m.GetLocalDB(), multiSig, true)
+	if err != nil {
+		return nil, err
+	}
+	txkv := getMultiSigAccountKV(multiSig, true)
+
+	var kvs []*types.KeyValue
+	kvs = append(kvs, txkv)
+	return kvs, nil
+}
+
+//多重签名账户交易被确认执行，更新对应资产的每日限额信息，以及txcount计数
+func (m *MultiSig) saveMultiSigTxCountUpdate(accTxCount mty.ReceiptTxCountUpdate, addOrRollback bool) ([]*types.KeyValue, error) {
+	multiSigAddr := accTxCount.MultiSigAddr
+	curTxCount := accTxCount.CurTxCount
+
+	//获取多重签名交易信息从db中
+	multiSig, err := getMultiSigAccount(m.GetLocalDB(), multiSigAddr)
+	if err != nil {
+		return nil, err
+	}
+	if multiSig == nil {
+		multisiglog.Error("saveMultiSigTxCountUpdate", "addOrRollback", addOrRollback, "accTxCount", accTxCount)
+		return nil, types.ErrAccountNotExist
+	}
+
+	if addOrRollback { //正常添加交易
+		if multiSig.TxCount+1 == curTxCount {
+			multiSig.TxCount = curTxCount
+		} else {
+			multisiglog.Error("saveMultiSigTxCountUpdate", "addOrRollback", addOrRollback, "accTxCount", accTxCount, "TxCount", multiSig.TxCount)
+			return nil, mty.ErrInvalidTxid
+		}
+	} else { //回滚删除交易
+		if multiSig.TxCount == curTxCount && curTxCount > 0 {
+			multiSig.TxCount = curTxCount - 1
+		}
+	}
+
+	err = setMultiSigAccount(m.GetLocalDB(), multiSig, true)
+	if err != nil {
+		return nil, err
+	}
+	txkv := getMultiSigAccountKV(multiSig, true)
+
+	var kvs []*types.KeyValue
+	kvs = append(kvs, txkv)
+	return kvs, nil
+}
+
+//获取多重签名账户的指定资产
+func (m *MultiSig) getMultiSigAccAssets(multiSigAddr string, assets *mty.Assets) (*types.Account, error) {
+	symbol := getRealSymbol(assets.Symbol)
+
+	acc, err := account.NewAccountDB(assets.Execer, symbol, m.GetStateDB())
+	if err != nil {
+		return &types.Account{}, err
+	}
+	var acc1 *types.Account
+
+	execaddress := dapp.ExecAddress(m.GetName())
+	acc1 = acc.LoadExecAccount(multiSigAddr, execaddress)
+	return acc1, nil
+}
+
+//内部共用接口
+
+//获取指定owner的weight权重，owner所在的index，所有owners的weight权重之和，以及owner是否存在
+func getOwnerInfoByAddr(multiSigAcc *mty.MultiSig, oldowner string) (uint64, int, uint64, int, bool) {
+	//首先遍历所有owners，确定对应的owner已近存在.
+	var findindex int
+	var totalweight uint64
+	var oldweight uint64
+	var totalowner int
+	flag := false
+
+	for index, owner := range multiSigAcc.Owners {
+		if owner.OwnerAddr == oldowner {
+			flag = true
+			findindex = index
+			oldweight = owner.Weight
+		}
+		totalweight += owner.Weight
+		totalowner++
+	}
+	//owner不存在
+	if !flag {
+		return 0, 0, totalweight, totalowner, false
+	}
+	return oldweight, findindex, totalweight, totalowner, true
+}
+
+//确认某笔交易是否已经达到确认需要的权重
+func isConfirmed(requiredWeight uint64, multiSigTx *mty.MultiSigTx) bool {
+	var totalweight uint64
+	for _, owner := range multiSigTx.ConfirmedOwner {
+		totalweight += owner.Weight
+	}
+	return totalweight >= requiredWeight
+}
+
+//确认某笔交易的额度是否满足每日限额,返回是否满足，以及新的newLastDay时间
+func isUnderLimit(blocktime int64, amount uint64, dailyLimit *mty.DailyLimit) (bool, int64) {
+
+	var lastDay int64
+	var newSpentToday uint64
+
+	nowtime := blocktime //types.Now().Unix()
+	newSpentToday = dailyLimit.SpentToday
+
+	//已经是新的一天了。需要更新LastDay为当前时间，SpentToday今日花费0
+	if nowtime > dailyLimit.LastDay+mty.OneDaySecond {
+		lastDay = nowtime
+		newSpentToday = 0
+	}
+
+	if newSpentToday+amount > dailyLimit.DailyLimit || newSpentToday+amount < newSpentToday {
+		return false, lastDay
+	}
+	return true, lastDay
+}
+
+//确定这个地址是否是此multiSigAcc多重签名账户的owner,如果是owner的话并返回weight权重
+func isOwner(multiSigAcc *mty.MultiSig, ownerAddr string) (uint64, bool) {
+	for _, owner := range multiSigAcc.Owners {
+		if owner.OwnerAddr == ownerAddr {
+			return owner.Weight, true
+		}
+	}
+	return 0, false
+}
+
+//删除指定index的owner从owners列表中
+func delOwner(Owners []*mty.Owner, index int) []*mty.Owner {
+	ownerSize := len(Owners)
+	multisiglog.Error("delOwner", "ownerSize", ownerSize, "index", index)
+
+	//删除第一个owner
+	if index == 0 {
+		Owners = Owners[1:]
+	} else if (ownerSize) == index+1 { //删除最后一个owner
+		multisiglog.Error("delOwner", "ownerSize", ownerSize)
+		Owners = Owners[0 : ownerSize-1]
+	} else {
+		Owners = append(Owners[0:index], Owners[index+1:]...)
+	}
+	return Owners
+}
+
+//指定资产是否设置了每日限额
+func isDailyLimit(multiSigAcc *mty.MultiSig, execer, symbol string) (int, bool) {
+	for index, dailyLimit := range multiSigAcc.DailyLimits {
+		if dailyLimit.Execer == execer && dailyLimit.Symbol == symbol {
+			return index, true
+		}
+	}
+	return 0, false
+}
+
+//owner是否已经确认过某个txid，已经确认过就返回index
+func isOwnerConfirmedTx(multiSigTx *mty.MultiSigTx, ownerAddr string) (int, bool) {
+	for index, owner := range multiSigTx.ConfirmedOwner {
+		if owner.OwnerAddr == ownerAddr {
+			return index, true
+		}
+	}
+	return 0, false
+}
+
+//通过txhash获取tx交易信息
+func getTxByHash(api client.QueueProtocolAPI, txHash string) (*types.TransactionDetail, error) {
+	hash, err := hex.DecodeString(txHash)
+	if err != nil {
+		multisiglog.Error("GetTxByHash DecodeString ", "hash", txHash)
+		return nil, err
+	}
+	txs, err := api.GetTransactionByHash(&types.ReqHashes{Hashes: [][]byte{hash}})
+	if err != nil {
+		multisiglog.Error("GetTxByHash", "hash", txHash)
+		return nil, err
+	}
+	if len(txs.Txs) != 1 {
+		multisiglog.Error("GetTxByHash", "len is not 1", len(txs.Txs))
+		return nil, mty.ErrTxHashNoMatch
+	}
+	if txs.Txs == nil {
+		multisiglog.Error("GetTxByHash", "tx hash not found", txHash)
+		return nil, mty.ErrTxHashNoMatch
+	}
+	return txs.Txs[0], nil
+}
+
+//从tx交易中解析payload信息
+func getMultiSigTxPayload(tx *types.TransactionDetail) (*mty.MultiSigAction, error) {
+	if !bytes.HasSuffix(tx.Tx.Execer, []byte(mty.MultiSigX)) {
+		multisiglog.Error("GetMultiSigTx", "tx.Tx.Execer", string(tx.Tx.Execer), "MultiSigX", mty.MultiSigX)
+		return nil, mty.ErrExecerHashNoMatch
+	}
+	var payload mty.MultiSigAction
+	err := types.Decode(tx.Tx.Payload, &payload)
+	if err != nil {
+		multisiglog.Error("GetMultiSigTx:Decode Payload", "error", err)
+		return nil, err
+	}
+	multisiglog.Error("GetMultiSigTx:Decode Payload", "payload", payload)
+	return &payload, nil
+}
+
+//bty 显示是大写，在底层mavl数据库中对应key值时使用小写
+func getRealSymbol(symbol string) string {
+	if symbol == types.BTY {
+		return "bty"
+	}
+	return symbol
+}

plugin/dapp/multisig/executor/multisigdb.go

+// Copyright Fuzamei Corp. 2018 All Rights Reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package executor
+
+import (
+	dbm "github.com/33cn/chain33/common/db"
+	"github.com/33cn/chain33/types"
+	mty "github.com/33cn/plugin/plugin/dapp/multisig/types"
+)
+
+// statedb相关接口
+func getMultiSigAccFromDb(db dbm.KV, multiSigAddr string) (*mty.MultiSig, error) {
+
+	//首先从statedb中获取MultiSigAccAddr的状态信息
+	value, err := db.Get(calcMultiSigAccountKey(multiSigAddr))
+	if err != nil {
+		multisiglog.Error("getMultiSigAccFromDb", "MultiSigAccAddr", multiSigAddr, "err", err)
+		return nil, err
+	}
+
+	// 没有找到返回错误ErrNotFound
+	if len(value) == 0 || err == types.ErrNotFound {
+		return nil, types.ErrNotFound
+	}
+
+	var multiSigAccount mty.MultiSig
+	err = types.Decode(value, &multiSigAccount)
+	if err != nil {
+		multisiglog.Error("getMultiSigAccFromDb", "MultiSigAccAddr", multiSigAddr, "types.Decode err", err)
+		return nil, err
+	}
+	return &multiSigAccount, nil
+}
+
+func setMultiSigAccToDb(db dbm.KV, multiSigAcc *mty.MultiSig) ([]byte, []byte) {
+	key := calcMultiSigAccountKey(multiSigAcc.MultiSigAddr)
+	value := types.Encode(multiSigAcc)
+
+	//即时保存到db中，方便同一个区块的下一个交易使用
+	db.Set(key, value)
+	//test
+	multisiglog.Info("setMultiSigAccToDb", "multiSigAcc", multiSigAcc)
+
+	return key, value
+}
+
+//获取db中指定多重签名地址上的txid对应的交易信息
+func getMultiSigAccTxFromDb(db dbm.KV, multiSigAddr string, txid uint64) (*mty.MultiSigTx, error) {
+
+	//首先从statedb中获取MultiSigAccTx的状态信息
+	value, err := db.Get(calcMultiSigAccTxKey(multiSigAddr, txid))
+	if err != nil {
+		multisiglog.Error("getMultiSigAccTxFromDb", "MultiSigAccAddr", multiSigAddr, "err", err)
+		return nil, err
+	}
+	// 没有找到返回错误ErrNotFound
+	if len(value) == 0 || err == types.ErrNotFound {
+		return nil, types.ErrNotFound
+	}
+
+	var multiSigAccTx mty.MultiSigTx
+	err = types.Decode(value, &multiSigAccTx)
+	if err != nil {
+		multisiglog.Error("getMultiSigAccTxFromDb", "MultiSigAccAddr", multiSigAddr, "types.Decode err", err)
+		return nil, err
+	}
+	return &multiSigAccTx, nil
+}
+func setMultiSigAccTxToDb(db dbm.KV, multiSigTx *mty.MultiSigTx) ([]byte, []byte) {
+	key := calcMultiSigAccTxKey(multiSigTx.MultiSigAddr, multiSigTx.Txid)
+	value := types.Encode(multiSigTx)
+	db.Set(key, value)
+
+	//test
+	multisiglog.Info("setMultiSigAccTxToDb", "multiSigTx", multiSigTx)
+	return key, value
+}
+
+// localdb相关接口
+func getMultiSigAccCountKV(count int64) *types.KeyValue {
+	tempcount := &types.Int64{Data: count}
+	countbytes := types.Encode(tempcount)
+	kv := &types.KeyValue{Key: calcMultiSigAccCountKey(), Value: countbytes}
+	return kv
+}
+
+//获取创建的多重账户的数量
+func getMultiSigAccCount(db dbm.KVDB) (int64, error) {
+	count := types.Int64{}
+	value, err := db.Get(calcMultiSigAccCountKey())
+	if err != nil && err != types.ErrNotFound {
+		return 0, err
+	}
+
+	if len(value) == 0 || err == types.ErrNotFound {
+		return 0, nil
+	}
+
+	err = types.Decode(value, &count)
+	if err != nil {
+		return 0, err
+	}
+
+	return count.Data, nil
+}
+
+//设置创建的多重账户的数量
+func setMultiSigAccCount(db dbm.KVDB, count int64) error {
+	value := &types.Int64{Data: count}
+	valuebytes := types.Encode(value)
+	return db.Set(calcMultiSigAccCountKey(), valuebytes)
+}
+
+//更新多重签名账户计数
+func updateMultiSigAccCount(cachedb dbm.KVDB, isadd bool) (*types.KeyValue, error) {
+	count, err := getMultiSigAccCount(cachedb)
+	if err != nil {
+		return nil, err
+	}
+	if isadd {
+		count++
+	} else {
+		if count == 0 {
+			return nil, mty.ErrAccCountNoMatch
+		}
+		count--
+	}
+	setMultiSigAccCount(cachedb, count)
+	//keyvalue
+	return getMultiSigAccCountKV(count), nil
+}
+
+//获取多重账户信息通过key值
+func getMultiSigAccount(db dbm.KVDB, addr string) (*mty.MultiSig, error) {
+	multiSigAcc := &mty.MultiSig{}
+	value, err := db.Get(calcMultiSigAcc(addr))
+	if err != nil && err != types.ErrNotFound {
+		return nil, err
+	}
+	//不存在返回一个ErrNotFound的错误，
+	if len(value) == 0 || err == types.ErrNotFound {
+		return nil, nil
+	}
+
+	err = types.Decode(value, multiSigAcc)
+	if err != nil {
+		return nil, err
+	}
+
+	return multiSigAcc, nil
+}
+
+//设置多重签名账户信息到db中通过key值,
+func setMultiSigAccount(db dbm.KVDB, multiSig *mty.MultiSig, isadd bool) error {
+	valuebytes := types.Encode(multiSig)
+	if isadd {
+		return db.Set(calcMultiSigAcc(multiSig.MultiSigAddr), valuebytes)
+	}
+	return db.Set(calcMultiSigAcc(multiSig.MultiSigAddr), nil)
+}
+
+//获取多重签名账户的kv对
+func getMultiSigAccountKV(multiSig *mty.MultiSig, isadd bool) *types.KeyValue {
+	accountbytes := types.Encode(multiSig)
+	var kv *types.KeyValue
+	if isadd {
+		kv = &types.KeyValue{Key: calcMultiSigAcc(multiSig.MultiSigAddr), Value: accountbytes}
+	} else {
+		kv = &types.KeyValue{Key: calcMultiSigAcc(multiSig.MultiSigAddr), Value: nil}
+	}
+	return kv
+}
+
+//更新多重签名账户列表
+func updateMultiSigAccList(db dbm.KVDB, addr string, index int64, isadd bool) (*types.KeyValue, error) {
+	oldaddr, err := getMultiSigAccList(db, index)
+	if err != nil {
+		return nil, err
+	}
+	if isadd && oldaddr != "" { //新增
+		multisiglog.Error("UpdateMultiSigAccList:getMultiSigAccList", "addr", addr, "oldaddr", oldaddr, "index", index, "err", err)
+		return nil, mty.ErrAccCountNoMatch
+	} else if !isadd && oldaddr == "" { // 删除
+		multisiglog.Error("UpdateMultiSigAccList:getMultiSigAccList", "addr", addr, "index", index, "err", err)
+		return nil, mty.ErrAccCountNoMatch
+	}
+
+	if isadd { //新增
+		db.Set(calcMultiSigAllAcc(index), []byte(addr))
+		kv := &types.KeyValue{Key: calcMultiSigAllAcc(index), Value: []byte(addr)}
+		return kv, nil
+	}
+	// 删除
+	db.Set(calcMultiSigAllAcc(index), nil)
+	kv := &types.KeyValue{Key: calcMultiSigAllAcc(index), Value: nil}
+	return kv, nil
+}
+
+func getMultiSigAccList(db dbm.KVDB, index int64) (string, error) {
+	value, err := db.Get(calcMultiSigAllAcc(index))
+	if err != nil && err != types.ErrNotFound {
+		return "", err
+	}
+
+	if len(value) == 0 || err == types.ErrNotFound {
+		return "", nil
+	}
+	return string(value), nil
+}
+
+//MultiSigTx:
+//获取多重签名账户的交易信息
+func getMultiSigTx(db dbm.KVDB, addr string, txid uint64) (*mty.MultiSigTx, error) {
+	multiSigTx := &mty.MultiSigTx{}
+	value, err := db.Get(calcMultiSigAccTx(addr, txid))
+	if err != nil && err != types.ErrNotFound {
+		return nil, err
+	}
+	//不存在返回nil
+	if len(value) == 0 || err == types.ErrNotFound {
+		return nil, nil
+	}
+
+	err = types.Decode(value, multiSigTx)
+	if err != nil {
+		return nil, err
+	}
+
+	return multiSigTx, nil
+}
+
+//设置多重签名账户交易信息到db中通过key值, 交易添加和回滚删除
+func setMultiSigTx(db dbm.KVDB, multiSigTx *mty.MultiSigTx, isadd bool) error {
+	valuebytes := types.Encode(multiSigTx)
+	if isadd {
+		return db.Set(calcMultiSigAccTx(multiSigTx.MultiSigAddr, multiSigTx.Txid), valuebytes)
+	}
+	return db.Set(calcMultiSigAccTx(multiSigTx.MultiSigAddr, multiSigTx.Txid), nil)
+}
+
+//获取多重签名账户交易的kv对
+func getMultiSigTxKV(multiSigTx *mty.MultiSigTx, isadd bool) *types.KeyValue {
+	accountbytes := types.Encode(multiSigTx)
+	var kv *types.KeyValue
+	if isadd {
+		kv = &types.KeyValue{Key: calcMultiSigAccTx(multiSigTx.MultiSigAddr, multiSigTx.Txid), Value: accountbytes}
+	} else {
+		kv = &types.KeyValue{Key: calcMultiSigAccTx(multiSigTx.MultiSigAddr, multiSigTx.Txid), Value: nil}
+	}
+	return kv
+}
+
+// 账户余额的更新,记录收到的币就可以
+func updateAddrReciver(cachedb dbm.KVDB, addr, execname, symbol string, amount int64, isadd bool) (*types.KeyValue, error) {
+	recv, err := getAddrReciver(cachedb, addr, execname, symbol)
+	if err != nil && err != types.ErrNotFound {
+		return nil, err
+	}
+	if isadd {
+		recv += amount
+	} else {
+		recv -= amount
+	}
+	setAddrReciver(cachedb, addr, execname, symbol, recv)
+	//keyvalue
+	return getAddrReciverKV(addr, execname, symbol, recv), nil
+}
+
+func getAddrReciverKV(addr, execname, symbol string, reciverAmount int64) *types.KeyValue {
+	assets := &mty.Assets{
+		Execer: execname,
+		Symbol: symbol,
+	}
+	reciver := &mty.AccountAssets{
+		MultiSigAddr: addr,
+		Assets:       assets,
+		Amount:       reciverAmount,
+	}
+	amountbytes := types.Encode(reciver)
+	kv := &types.KeyValue{Key: calcAddrRecvAmountKey(addr, execname, symbol), Value: amountbytes}
+	return kv
+}
+
+func getAddrReciver(db dbm.KVDB, addr, execname, symbol string) (int64, error) {
+	reciver := mty.AccountAssets{}
+	addrReciver, err := db.Get(calcAddrRecvAmountKey(addr, execname, symbol))
+	if err != nil && err != types.ErrNotFound {
+		return 0, err
+	}
+	if len(addrReciver) == 0 {
+		return 0, nil
+	}
+	err = types.Decode(addrReciver, &reciver)
+	if err != nil {
+		return 0, err
+	}
+	return reciver.Amount, nil
+}
+
+func setAddrReciver(db dbm.KVDB, addr, execname, symbol string, reciverAmount int64) error {
+	kv := getAddrReciverKV(addr, execname, symbol, reciverAmount)
+	return db.Set(kv.Key, kv.Value)
+}
+
+//MultiSigAccAddress:
+//获取指定地址创建的所有MultiSigAddress
+func getMultiSigAddress(db dbm.KVDB, createAddr string) (*mty.AccAddress, error) {
+	address := &mty.AccAddress{}
+	value, err := db.Get(calcMultiSigAccCreateAddr(createAddr))
+	if err != nil && err != types.ErrNotFound {
+		return nil, err
+	}
+	//不存在返回nil
+	if len(value) == 0 || err == types.ErrNotFound {
+		return address, nil
+	}
+
+	err = types.Decode(value, address)
+	if err != nil {
+		return nil, err
+	}
+
+	return address, nil
+}
+
+//需要处理交易添加和回滚删除
+func setMultiSigAddress(db dbm.KVDB, createAddr, multiSigAddr string, isadd bool) *types.KeyValue {
+	accAddress, err := getMultiSigAddress(db, createAddr)
+	if err != nil {
+		return nil
+	}
+
+	var found = false
+	var foundindex int
+	for index, addr := range accAddress.Address {
+		if multiSigAddr == addr {
+			found = true
+			foundindex = index
+			break
+		}
+	}
+	if isadd && !found {
+		accAddress.Address = append(accAddress.Address, multiSigAddr)
+	} else if !isadd && found {
+		accAddress.Address = append(accAddress.Address[0:foundindex], accAddress.Address[foundindex+1:]...)
+	}
+
+	key := calcMultiSigAccCreateAddr(createAddr)
+	value := types.Encode(accAddress)
+
+	db.Set(key, value)
+	return &types.KeyValue{Key: key, Value: value}
+}
+
+//获取指定地址创建的所有MultiSigAddress
+func getMultiSigAccAllAddress(db dbm.KVDB, createAddr string) (*mty.AccAddress, error) {
+	address := &mty.AccAddress{}
+	value, err := db.Get(calcMultiSigAccCreateAddr(createAddr))
+	if err != nil && err != types.ErrNotFound {
+		return nil, err
+	}
+	//不存在返回nil
+	if len(value) == 0 || err == types.ErrNotFound {
+		return address, nil
+	}
+
+	err = types.Decode(value, address)
+	if err != nil {
+		return nil, err
+	}
+
+	return address, nil
+}
+
+//获取指定账户地址上接受的所有资产
+func getMultiSigAccAllAssets(db dbm.KVDB, addr string) ([][]byte, error) {
+	values, err := db.List(calcAddrRecvAmountPrefix(addr), nil, 0, 0)
+	if err != nil && err != types.ErrNotFound {
+		return nil, err
+	}
+	return values, nil
+}

plugin/dapp/multisig/executor/query.go

+// Copyright Fuzamei Corp. 2018 All Rights Reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package executor
+
+import (
+	"github.com/33cn/chain33/common/address"
+	"github.com/33cn/chain33/types"
+	mty "github.com/33cn/plugin/plugin/dapp/multisig/types"
+)
+
+//Query_MultiSigAccCount 获取多重签名账户的数量，用于分批获取多重签名账户地址
+//返回ReplyMultiSigAccounts
+func (m *MultiSig) Query_MultiSigAccCount(in *types.ReqNil) (types.Message, error) {
+	db := m.GetLocalDB()
+	count, err := getMultiSigAccCount(db)
+	if err != nil {
+		return nil, err
+	}
+
+	return &types.Int64{Data: count}, nil
+}
+
+//Query_MultiSigAccounts 获取指定区间的多重签名账户
+//输入：
+//message ReqMultiSigAccs {
+//	int64	start	= 1;
+//	int64	end		= 2;
+//输出：
+//message ReplyMultiSigAccs {
+//    repeated string address = 1;
+func (m *MultiSig) Query_MultiSigAccounts(in *mty.ReqMultiSigAccs) (types.Message, error) {
+	accountAddrs := &mty.ReplyMultiSigAccs{}
+
+	if in.Start > in.End || in.Start < 0 {
+		return nil, types.ErrInvalidParam
+	}
+
+	db := m.GetLocalDB()
+	totalcount, err := getMultiSigAccCount(db)
+	if err != nil {
+		return nil, err
+	}
+	if totalcount == 0 {
+		return accountAddrs, nil
+	}
+	if in.End > totalcount {
+		return nil, types.ErrInvalidParam
+	}
+	for index := in.Start; index <= in.End; index++ {
+		addr, err := getMultiSigAccList(db, index)
+		if err == nil {
+			accountAddrs.Address = append(accountAddrs.Address, addr)
+		}
+	}
+	return accountAddrs, nil
+}
+
+//Query_MultiSigAccountInfo 获取指定多重签名账号的状态信息
+//输入：
+//message ReqMultiSigAccountInfo {
+//	string MultiSigAccAddr = 1;
+//返回：
+//message MultiSig {
+//    string 							createAddr        	= 1;
+//    string 							multiSigAddr      	= 2;
+//    repeated Owner           			owners				= 3;
+//    repeated DailyLimit          		dailyLimits   		= 4;
+//    uint64           					txCount				= 5;
+//	  uint64           					requiredWeight		= 6;
+func (m *MultiSig) Query_MultiSigAccountInfo(in *mty.ReqMultiSigAccInfo) (types.Message, error) {
+	if in == nil {
+		return nil, types.ErrInvalidParam
+	}
+	db := m.GetLocalDB()
+	addr := in.MultiSigAccAddr
+
+	if err := address.CheckMultiSignAddress(addr); err != nil {
+		return nil, types.ErrInvalidAddress
+	}
+	multiSigAcc, err := getMultiSigAccount(db, addr)
+	if err != nil {
+		return nil, err
+	}
+	if multiSigAcc == nil {
+		multiSigAcc = &mty.MultiSig{}
+	}
+	return multiSigAcc, nil
+}
+
+//Query_MultiSigAccTxCount 获取指定多重签名账号下的tx交易数量
+//输入：
+//message ReqMultiSigAccountInfo {
+//	string MultiSigAccAddr = 1;
+//返回：
+//uint64
+func (m *MultiSig) Query_MultiSigAccTxCount(in *mty.ReqMultiSigAccInfo) (types.Message, error) {
+	if in == nil {
+		return nil, types.ErrInvalidParam
+	}
+	db := m.GetLocalDB()
+	addr := in.MultiSigAccAddr
+
+	if err := address.CheckMultiSignAddress(addr); err != nil {
+		return nil, types.ErrInvalidAddress
+	}
+
+	multiSigAcc, err := getMultiSigAccount(db, addr)
+	if err != nil {
+		return nil, err
+	}
+	if multiSigAcc == nil {
+		return nil, mty.ErrAccountHasExist
+	}
+	return &mty.Uint64{Data: multiSigAcc.TxCount}, nil
+}
+
+//Query_MultiSigTxids 获取txids通过设置的过滤条件和区间，pending, executed
+//输入：
+//message ReqMultiSigTxids {
+//  string multisigaddr = 1;
+//	uint64 fromtxid = 2;
+//	uint64 totxid = 3;
+//	bool   pending = 4;
+//	bool   executed	= 5;
+// 返回:
+//message ReplyMultiSigTxids {
+//  string 			multisigaddr = 1;
+//	repeated uint64	txids		 = 2;
+func (m *MultiSig) Query_MultiSigTxids(in *mty.ReqMultiSigTxids) (types.Message, error) {
+	if in == nil || in.FromTxId > in.ToTxId || in.FromTxId < 0 {
+		return nil, types.ErrInvalidParam
+	}
+
+	db := m.GetLocalDB()
+	addr := in.MultiSigAddr
+
+	if err := address.CheckMultiSignAddress(addr); err != nil {
+		return nil, types.ErrInvalidAddress
+	}
+	multiSigAcc, err := getMultiSigAccount(db, addr)
+	if err != nil {
+		return nil, err
+	}
+	if multiSigAcc == nil || multiSigAcc.TxCount <= in.ToTxId {
+		return nil, types.ErrInvalidParam
+	}
+
+	multiSigTxids := &mty.ReplyMultiSigTxids{}
+	multiSigTxids.MultiSigAddr = addr
+	for txid := in.FromTxId; txid <= in.ToTxId; txid++ {
+		multiSigTx, err := getMultiSigTx(db, addr, txid)
+		if err != nil || multiSigTx == nil {
+			multisiglog.Error("Query_MultiSigTxids:getMultiSigTx", "addr", addr, "txid", txid, "err", err)
+			continue
+		}
+		findTxid := txid
+		//查找Pending/Executed的交易txid
+		if in.Pending && !multiSigTx.Executed || in.Executed && multiSigTx.Executed {
+			multiSigTxids.Txids = append(multiSigTxids.Txids, findTxid)
+		}
+	}
+	return multiSigTxids, nil
+
+}
+
+//Query_MultiSigTxInfo 获取txid交易的信息，以及参与确认的owner信息
+//输入:
+//message ReqMultiSigTxInfo {
+//  string multisigaddr = 1;
+//	uint64 txid = 2;
+//返回:
+//message ReplyMultiSigTxInfo {
+//    MultiSigTransaction multisigtxinfo = 1;
+//    repeated Owner confirmowners = 3;
+func (m *MultiSig) Query_MultiSigTxInfo(in *mty.ReqMultiSigTxInfo) (types.Message, error) {
+	if in == nil {
+		return nil, types.ErrInvalidParam
+	}
+	db := m.GetLocalDB()
+	addr := in.MultiSigAddr
+	txid := in.TxId
+
+	if err := address.CheckMultiSignAddress(addr); err != nil {
+		return nil, types.ErrInvalidAddress
+	}
+
+	multiSigTx, err := getMultiSigTx(db, addr, txid)
+	if err != nil {
+		return nil, err
+	}
+	if multiSigTx == nil {
+		multiSigTx = &mty.MultiSigTx{}
+	}
+	return multiSigTx, nil
+}
+
+//Query_MultiSigTxConfirmedWeight 获取txid交易已经确认的权重之和
+//输入:
+//message ReqMultiSigTxInfo {
+//  string multisigaddr = 1;
+//	uint64 txid = 2;
+//返回:
+//message Int64
+func (m *MultiSig) Query_MultiSigTxConfirmedWeight(in *mty.ReqMultiSigTxInfo) (types.Message, error) {
+	if in == nil {
+		return nil, types.ErrInvalidParam
+	}
+	db := m.GetLocalDB()
+	addr := in.MultiSigAddr
+	txid := in.TxId
+
+	if err := address.CheckMultiSignAddress(addr); err != nil {
+		return nil, types.ErrInvalidAddress
+	}
+
+	multiSigTx, err := getMultiSigTx(db, addr, txid)
+	if err != nil {
+		return nil, err
+	}
+	if multiSigTx == nil {
+		return nil, mty.ErrTxidNotExist
+	}
+	var totalWeight uint64
+	for _, owner := range multiSigTx.ConfirmedOwner {
+		totalWeight += owner.Weight
+	}
+
+	return &mty.Uint64{Data: totalWeight}, nil
+}
+
+//Query_MultiSigAccUnSpentToday  获取指定资产当日还能使用的免多重签名的余额
+//输入:
+//message ReqMultiSigAccUnSpentToday {
+//	string multiSigAddr = 1;
+//	string execer 		= 2;
+//	string symbol 		= 3;
+//返回:
+//message ReplyMultiSigAccUnSpentToday {
+//	uint64 	amount = 1;
+func (m *MultiSig) Query_MultiSigAccUnSpentToday(in *mty.ReqAccAssets) (types.Message, error) {
+	if in == nil {
+		return nil, types.ErrInvalidParam
+	}
+	db := m.GetLocalDB()
+	addr := in.MultiSigAddr
+	isAll := in.IsAll
+
+	if err := address.CheckMultiSignAddress(addr); err != nil {
+		return nil, types.ErrInvalidAddress
+	}
+	multiSigAcc, err := getMultiSigAccount(db, addr)
+	if err != nil {
+		return nil, err
+	}
+
+	replyUnSpentAssets := &mty.ReplyUnSpentAssets{}
+	if multiSigAcc == nil {
+		return replyUnSpentAssets, nil
+	}
+	if isAll {
+		for _, dailyLimit := range multiSigAcc.DailyLimits {
+			var unSpentAssets mty.UnSpentAssets
+			assets := &mty.Assets{
+				Execer: dailyLimit.Execer,
+				Symbol: dailyLimit.Symbol,
+			}
+			unSpentAssets.Assets = assets
+			unSpentAssets.Amount = 0
+			if dailyLimit.DailyLimit > dailyLimit.SpentToday {
+				unSpentAssets.Amount = dailyLimit.DailyLimit - dailyLimit.SpentToday
+			}
+			replyUnSpentAssets.UnSpentAssets = append(replyUnSpentAssets.UnSpentAssets, &unSpentAssets)
+		}
+	} else {
+		//assets资产合法性校验
+		err := mty.IsAssetsInvalid(in.Assets.Execer, in.Assets.Symbol)
+		if err != nil {
+			return nil, err
+		}
+
+		for _, dailyLimit := range multiSigAcc.DailyLimits {
+			var unSpentAssets mty.UnSpentAssets
+
+			if dailyLimit.Execer == in.Assets.Execer && dailyLimit.Symbol == in.Assets.Symbol {
+				assets := &mty.Assets{
+					Execer: dailyLimit.Execer,
+					Symbol: dailyLimit.Symbol,
+				}
+				unSpentAssets.Assets = assets
+				unSpentAssets.Amount = 0
+				if dailyLimit.DailyLimit > dailyLimit.SpentToday {
+					unSpentAssets.Amount = dailyLimit.DailyLimit - dailyLimit.SpentToday
+				}
+				replyUnSpentAssets.UnSpentAssets = append(replyUnSpentAssets.UnSpentAssets, &unSpentAssets)
+				break
+			}
+		}
+	}
+	return replyUnSpentAssets, nil
+}
+
+//Query_MultiSigAccAssets  获取多重签名账户上的所有资产，或者指定资产
+//输入:
+//message ReqAccAssets {
+//	string multiSigAddr = 1;
+//	Assets assets 		= 2;
+//	bool   isAll 		= 3;
+//返回:
+//message MultiSigAccAssets {
+//	Assets 		assets 		= 1;
+//	int64   	recvAmount 	= 2;
+//   Account 	account 	= 3;
+func (m *MultiSig) Query_MultiSigAccAssets(in *mty.ReqAccAssets) (types.Message, error) {
+	if in == nil {
+		return nil, types.ErrInvalidParam
+	}
+	//多重签名地址或者普通地址
+	if err := address.CheckMultiSignAddress(in.MultiSigAddr); err != nil {
+		if err = address.CheckAddress(in.MultiSigAddr); err != nil {
+			return nil, types.ErrInvalidAddress
+		}
+	}
+
+	replyAccAssets := &mty.ReplyAccAssets{}
+	//获取账户上的所有资产数据
+	if in.IsAll {
+		values, err := getMultiSigAccAllAssets(m.GetLocalDB(), in.MultiSigAddr)
+		if err != nil {
+			return nil, err
+		}
+		if len(values) != 0 {
+			for _, value := range values {
+				reciver := mty.AccountAssets{}
+				err = types.Decode(value, &reciver)
+				if err != nil {
+					continue
+				}
+				accAssets := &mty.AccAssets{}
+				account, _ := m.getMultiSigAccAssets(reciver.MultiSigAddr, reciver.Assets)
+				accAssets.Account = account
+				accAssets.Assets = reciver.Assets
+				accAssets.RecvAmount = reciver.Amount
+
+				replyAccAssets.AccAssets = append(replyAccAssets.AccAssets, accAssets)
+			}
+		}
+	} else { //获取账户上的指定资产数据
+		accAssets := &mty.AccAssets{}
+		//assets资产合法性校验
+		err := mty.IsAssetsInvalid(in.Assets.Execer, in.Assets.Symbol)
+		if err != nil {
+			return nil, err
+		}
+		account, _ := m.getMultiSigAccAssets(in.MultiSigAddr, in.Assets)
+		accAssets.Account = account
+		accAssets.Assets = in.Assets
+
+		amount, _ := getAddrReciver(m.GetLocalDB(), in.MultiSigAddr, in.Assets.Execer, in.Assets.Symbol)
+		accAssets.RecvAmount = amount
+
+		replyAccAssets.AccAssets = append(replyAccAssets.AccAssets, accAssets)
+	}
+
+	return replyAccAssets, nil
+}
+
+//Query_MultiSigAccAllAddress 获取指定地址创建的所有多重签名账户
+//输入:
+//createaddr
+//返回:
+//[]string
+func (m *MultiSig) Query_MultiSigAccAllAddress(in *mty.ReqMultiSigAccInfo) (types.Message, error) {
+	if in == nil {
+		return nil, types.ErrInvalidParam
+	}
+	if err := address.CheckAddress(in.MultiSigAccAddr); err != nil {
+		return nil, types.ErrInvalidAddress
+	}
+	return getMultiSigAccAllAddress(m.GetLocalDB(), in.MultiSigAccAddr)
+}

plugin/dapp/multisig/plugin.go

+package multisig
+
+import (
+	"github.com/33cn/chain33/pluginmgr"
+	"github.com/33cn/plugin/plugin/dapp/multisig/commands"
+	"github.com/33cn/plugin/plugin/dapp/multisig/executor"
+	"github.com/33cn/plugin/plugin/dapp/multisig/rpc"
+	mty "github.com/33cn/plugin/plugin/dapp/multisig/types"
+)
+
+func init() {
+	pluginmgr.Register(&pluginmgr.PluginBase{
+		Name:     mty.MultiSigX,
+		ExecName: executor.GetName(),
+		Exec:     executor.Init,
+		Cmd:      commands.MultiSigCmd,
+		RPC:      rpc.Init,
+	})
+}

plugin/dapp/multisig/proto/Makefile

+all:
+	./create_protobuf.sh

plugin/dapp/multisig/proto/create_protobuf.sh

+#!/bin/sh
+protoc --go_out=plugins=grpc:../types ./*.proto --proto_path=. --proto_path="../../../../vendor/github.com/33cn/chain33/types/proto/"

plugin/dapp/multisig/proto/multisig.proto

+syntax = "proto3";
+import "account.proto";
+package types;
+
+//////////////////////////////////////////////////////////////////////////////
+// message for multisig start/////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////
+//多重签名账户的状态信息，存在在statedb中，通过多重签名账户作为key值
+//createaddr: 创建多重签名地址的创建者账户
+//multisigaddr: 多重签名地址
+//owners: 可以操作此多重签名地址的owner账户列表
+//DailyLimit: 不同资产的每日限额，通过symbol来区分，本连的原生币，以及跨链过来的其他链的原生币
+//txCount:记录此多重签名地址上提交的withdraw交易数
+//requiredweight:确认一笔withdraw交易需要的权重。
+message MultiSig {
+    string 								createAddr        	= 1;
+    string 								multiSigAddr      	= 2;
+    repeated Owner           			owners				= 3;
+    repeated DailyLimit          		dailyLimits   		= 4;
+    uint64           					txCount				= 5;
+	uint64           					requiredWeight		= 6;
+}
+
+//这个地址是否已经确认某个交易
+message ConfirmedOwner {
+    repeated Owner  confirmedOwner = 1;
+}
+
+//记录提交的交易详情，在满足确认条件后执行data中的交易
+//txHash:用于存贮提交的确认交易。存贮在localdb中，通过txhash可以获取
+message MultiSigTx {
+	uint64			txid			= 1;
+    string			txHash			= 2;
+    bool			executed		= 3;
+	uint64			txType			= 4;
+	string 			multiSigAddr    = 5;
+	repeated Owner  confirmedOwner 	= 6;
+	
+}
+// owner 结构体：owner账户地址，以及权重
+message Owner {
+	string ownerAddr =1;
+    uint64 weight=2;
+}
+
+// 资产symbol的定义，可能存在不同的平行链上发布相同名字的token,
+//或者在主链发布一个token：HYB 而在guodun的平行链上也会发布一个token：HYB
+// coins.bty和coins.guodun
+//1:原始数据
+//主链上：原始币symbol：BTY,token.symbol(例如：TEST)
+//guodun平行链上的原始币symbol：guodun，token.symbol(例如：TEST)
+//2:主链原始币转移到平行链上：
+//guodun平行链上的现有原始币symbol：guodun，token.symbol(例如：TEST)
+//以及主链转移过来的symbol： coins.BTY和token.TEST (主链转移过来的资产在平行链上的symbol)
+
+//每日资产限额，不同的资产价格不一致，需要设置各自的每日限额。没有设置或者限额是0时，表示不能取币
+//spentToday今天已经花费的额度。用于和dailyLimit做对比，超过每日限额时需要多重签名
+//lastDay记录当天开始的时间戳，新的一天需要重置spentToday为初始值0，并修改lastDay的时间戳
+message DailyLimit {
+	string symbol 		=1;
+	string execer 		=2;
+    uint64 dailyLimit	=3;
+	uint64 spentToday	=4;
+	int64  lastDay 		=5;
+}
+
+message SymbolDailyLimit {
+	string symbol 		=1;
+	string execer 		=2;
+    uint64 dailyLimit	=3;
+}
+
+//MultiSig 所有可能的交易action	
+message MultiSigAction {
+    oneof value {
+        MultiSigAccCreate       	multiSigAccCreate   	= 1;
+        MultiSigOwnerOperate    	multiSigOwnerOperate 	= 2;
+        MultiSigAccOperate    		multiSigAccOperate 		= 3;
+        MultiSigConfirmTx        	multiSigConfirmTx       = 4;//确认或者撤销已确认
+		MultiSigExecTransferTo     	multiSigExecTransferTo 	= 5;//合约中外部账户转账到多重签名账户，Addr --->multiSigAddr
+		MultiSigExecTransferFrom    multiSigExecTransferFrom = 6;//合约中多重签名账户转账到外部账户，multiSigAddr--->Addr
+
+    }
+    int32 Ty = 7;
+}
+
+//创建多重签名账户时需要的信息：创建时最少初始化两个owners，资产的每日限额初始时可以不设置
+message MultiSigAccCreate {
+    repeated Owner						owners				= 1;
+	uint64          					requiredWeight		= 2;
+    SymbolDailyLimit          			dailyLimit			= 3;
+}
+
+//对MultiSigAccount账户owner的操作：add/del/replace/modify
+message MultiSigOwnerOperate {
+	string multiSigAccAddr	= 1;
+    string oldOwner 		= 2;
+    string newOwner			= 3;
+	uint64 newWeight		= 4;
+	uint64 operateFlag		= 5;
+}
+
+//对MultiSigAccount账户的操作：modify/add:SymbolDailyLimit,requiredweight
+//修改或者添加每日限额，或者请求权重的值。
+message MultiSigAccOperate {
+	string 				multiSigAccAddr		= 1;
+	SymbolDailyLimit 	dailyLimit 			= 2;
+	uint64 				newRequiredWeight 	= 3;
+	bool 				operateFlag			= 4;
+}
+
+//多重签名合约中账户之间转币操作:增加一个from的字段实现MultiSigAddr--->addr之间的转账
+//需要判断from地址是否是多重签名地址
+//将MultiSig合约中from地址上execname+symbol的资产转移到to地址
+message MultiSigExecTransferFrom {
+	string symbol		= 1;
+	int64  amount		= 2;
+	string note			= 3;
+	string execname		= 4;
+	string to			= 5;
+	string from			= 6;
+}
+//多重签名合约中账户之间转币操作: addr --->MultiSigAddr之间的转账
+//需要判断to地址是否是多重签名地址
+//将MultiSig合约中签名地址上execname+symbol的资产转移到to地址
+message MultiSigExecTransferTo {
+	string symbol		= 1;
+	int64  amount		= 2;
+	string note			= 3;
+	string execname		= 4;
+	string to			= 5;
+}
+
+//多重签名账户withdraw交易的确认或者取消确认
+//multisigaccaddr:多重签名账户地址
+//transactionid:多重签名账户上的withdraw交易的内部id
+message MultiSigConfirmTx {
+	string multiSigAccAddr	= 1;
+	uint64 txId				= 2;
+	bool   confirmOrRevoke	= 3;
+}
+
+
+
+//query的接口：
+//第一步:获取所有多重签名账号
+//第二步:获取指定多重签名账号的状态信息：包含创建者，owners，weight权重，以及各个资产的每日限量
+//第三步:获取指定多重签名账户下的peding或者executed的交易id
+//第四步:获取指定txid的详细信息：已经确认此交易的owners以及交易的详细信息
+//第五步:获取指定多重签名账户当日的免多重签名的可用余额
+
+//获取所有多重签名账号
+message ReqMultiSigAccs {
+	int64	start	= 1;
+	int64	end		= 2;
+}
+
+message ReplyMultiSigAccs {
+    repeated string address = 1;
+}
+
+//获取指定多重签名账号的状态信息
+message ReqMultiSigAccInfo {
+	string     multiSigAccAddr = 1;
+}
+
+//指定多重签名账号的状态信息
+message ReplyMultiSigAccInfo {
+    string 								createAddr        	= 1;
+    string 								multiSigAddr      	= 2;
+    repeated Owner           			owners				= 3;
+    repeated DailyLimit          		dailyLimits   		= 4;
+    uint64           					txCount				= 5;
+	uint64           					requiredWeight		= 6;
+}
+
+//获取txids设置过滤条件和区间，pending, executed
+message ReqMultiSigTxids {
+    string	multiSigAddr	= 1;
+	uint64	fromTxId		= 2;
+	uint64	toTxId			= 3;
+	bool   	pending			= 4;
+	bool   	executed		= 5;
+}
+message ReplyMultiSigTxids {
+    string			multiSigAddr	= 1;
+	repeated uint64	txids			= 2;
+}
+
+
+//获取txid交易的信息，以及参与确认的owner信息
+message ReqMultiSigTxInfo {
+    string	multiSigAddr	= 1;
+	uint64	txId			= 2;
+}
+
+message ReplyMultiSigTxInfo {
+    MultiSigTx			multiSigTxInfo	= 1;
+}
+
+//获取指定资产当日剩余的免多重签名的余额
+message ReqMultiSigAccUnSpentToday {
+	string multiSigAddr = 1;
+	string execer 		= 2;
+	string symbol 		= 3;
+}
+
+message ReplyUnSpentAssets {
+	repeated UnSpentAssets  unSpentAssets = 3;
+}
+
+message UnSpentAssets {
+	Assets assets = 1; 
+	uint64 amount = 2;
+}
+		
+//交易执行结果的Receipt信息:
+
+//TyLogMultiSigAccCreate交易的执行Receipt
+message ReceiptMultiSig  {
+	string multiSigAddr = 1;
+}
+
+//owner的操作:
+//TyLogMultiSigOwnerAdd     = 10001 //输出add的owner：addr和weight
+//TyLogMultiSigOwnerDel     = 10002 //输出del的owner：addr和weight
+
+message ReceiptOwnerAddOrDel  {
+	string  multiSigAddr 	= 1;
+	Owner   owner 			= 2;
+	bool    addOrDel	 	= 3;
+}
+
+//TyLogMultiSigOwnerModify  = 10003 //输出modify的owner：preweight以及currentweight
+//TyLogMultiSigOwnerReplace = 10004 //输出old的owner的信息：以及当前的owner信息：addr+weight
+message ReceiptOwnerModOrRep  {
+	string multiSigAddr 	= 1;
+	Owner  prevOwner 		= 2;
+	Owner  currentOwner 	= 3;
+	bool   modOrRep	 		= 4;
+}	
+
+//多重签名账户的操作：ReqWeight，AssetDailyLimit
+//TyLogMultiSigAccWeightModify     = 10005 //输出修改前后确认权重的值：preReqWeight和curReqWeight
+message ReceiptWeightModify  {
+	string  multiSigAddr 	= 1;
+	uint64  prevWeight 		= 2;
+	uint64  currentWeight 	= 3;
+}
+//TyLogMultiSigAccDailyLimitAdd    = 10006 //输出add的DailyLimit：Symbol和DailyLimit
+//TyLogMultiSigAccDailyLimitModify = 10007 //输出modify的DailyLimit：preDailyLimit以及currentDailyLimit
+message ReceiptDailyLimitOperate  {
+	string  		multiSigAddr 		= 1;
+	DailyLimit		prevDailyLimit 		= 2;
+	DailyLimit  	curDailyLimit	= 3;
+	bool 			addOrModify 		= 4;
+}		
+	
+//交易确认或者撤销（撤销值针对未执行的交易）
+//TyLogMultiSigConfirmTx       = 10008 //输出确认的交易id，以及owner信息：addr+weight
+//TyLogMultiSigConfirmTxRevoke = 10009 //输出撤销确认的交易id，以及owner信息：addr+weight
+message ReceiptConfirmTx  {
+	MultiSigTxOwner multiSigTxOwner		= 1;
+	bool 			confirmeOrRevoke 	= 2;
+}
+//可能会修改dailyLimit的相关属性
+message ReceiptAccDailyLimitUpdate  {
+	string  		multiSigAddr	= 1;
+	DailyLimit  	prevDailyLimit	= 2;
+	DailyLimit  	curDailyLimit	= 3;
+}
+//执行MultiSigAcc相关的交易可能会修改tx的执行状态和增加确认owner
+message ReceiptMultiSigTx  {
+	MultiSigTxOwner multiSigTxOwner	= 1;
+	bool  			prevExecuted 	= 2;
+	bool  			curExecuted 	= 3;
+	bool  			submitOrConfirm = 4;
+	string			txHash			= 5;
+	uint64			txType			= 6;
+
+}
+
+message ReceiptTxCountUpdate  {
+	string  		multiSigAddr	= 1;
+	uint64          curTxCount		= 2;
+}
+
+message MultiSigTxOwner  {
+	string  		multiSigAddr	= 1;
+	uint64          txid			= 2;
+	Owner      		confirmedOwner	= 3;
+}
+
+//具体转币的处理;
+//TyLogMultiSigExecTransfer = 10010 
+//入币：将from地址在MultiSig合约中的币转移到指定的多重签名账户ExecTransfer中，并将其冻结ExecFrozen
+//注释：使用chain33/types中定义的ReceiptExecAccountTransfer即可
+
+//TyLogMultiSigWithdraw     = 10011 
+//出币：将多重签名地址上冻结的币转给MultiSig合约中TO地址上ExecTransferFrozen
+//注释：使用chain33/types中定义的ReceiptExecAccountTransfer即可	
+
+
+message Uint64 {
+	uint64	data	= 1;
+}
+
+//记录账户收到固定资产的数量
+message AccountAssets {
+	string multiSigAddr = 1;
+	Assets assets 		= 2;
+	int64  amount 		= 3;
+}
+
+//获取多重签名账户上的指定资产或者所有资产
+message ReqAccAssets {
+	string multiSigAddr = 1;
+	Assets assets 		= 2;
+	bool   isAll 		= 3;
+}
+
+message ReplyAccAssets {
+	repeated AccAssets accAssets = 1;
+}
+
+//账户资产信息
+message AccAssets {
+	Assets 		assets 		= 1;
+	int64   	recvAmount 	= 2;
+    Account 	account 	= 3;
+}
+
+message Assets {
+	string execer 		= 1;
+	string symbol 		= 2;
+}
+
+//账户地址列表
+message AccAddress {
+	repeated string address = 1;
+}
\ No newline at end of file

plugin/dapp/multisig/rpc/jrpc_channel_test.go

+// Copyright Fuzamei Corp. 2018 All Rights Reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package rpc_test
+
+import (
+	"strings"
+	"testing"
+
+	commonlog "github.com/33cn/chain33/common/log"
+	"github.com/33cn/chain33/rpc/jsonclient"
+	"github.com/33cn/chain33/types"
+	"github.com/33cn/chain33/util/testnode"
+	mty "github.com/33cn/plugin/plugin/dapp/multisig/types"
+	"github.com/stretchr/testify/assert"
+	// 注册system和plugin 包
+	rpctypes "github.com/33cn/chain33/rpc/types"
+	_ "github.com/33cn/chain33/system"
+	_ "github.com/33cn/plugin/plugin"
+)
+
+func init() {
+	commonlog.SetLogLevel("error")
+}
+
+func TestJRPCChannel(t *testing.T) {
+	// 启动RPCmocker
+	mocker := testnode.New("--notset--", nil)
+	defer func() {
+		mocker.Close()
+	}()
+	mocker.Listen()
+
+	jrpcClient := mocker.GetJSONC()
+
+	testCases := []struct {
+		fn func(*testing.T, *jsonclient.JSONClient) error
+	}{
+		{fn: testCreateMultiSigAccCreateCmd},
+		{fn: testCreateMultiSigAccOwnerAddCmd},
+		{fn: testCreateMultiSigAccOwnerDelCmd},
+		{fn: testCreateMultiSigAccOwnerModifyCmd},
+		{fn: testCreateMultiSigAccOwnerReplaceCmd},
+		{fn: testCreateMultiSigAccWeightModifyCmd},
+		{fn: testCreateMultiSigAccDailyLimitModifyCmd},
+		{fn: testCreateMultiSigConfirmTxCmd},
+		{fn: testCreateMultiSigAccTransferInCmd},
+		{fn: testCreateMultiSigAccTransferOutCmd},
+
+		{fn: testGetMultiSigAccCountCmd},
+		{fn: testGetMultiSigAccountsCmd},
+		{fn: testGetMultiSigAccountInfoCmd},
+		{fn: testGetMultiSigAccTxCountCmd},
+		{fn: testGetMultiSigTxidsCmd},
+		{fn: testGetMultiSigTxInfoCmd},
+		{fn: testGetGetMultiSigTxConfirmedWeightCmd},
+		{fn: testGetGetMultiSigAccUnSpentTodayCmd},
+		{fn: testGetMultiSigAccAssetsCmd},
+		{fn: testGetMultiSigAccAllAddressCmd},
+	}
+	for index, testCase := range testCases {
+		err := testCase.fn(t, jrpcClient)
+		if err == nil {
+			continue
+		}
+		assert.NotEqualf(t, err, types.ErrActionNotSupport, "test index %d", index)
+		if strings.Contains(err.Error(), "rpc: can't find") {
+			assert.FailNowf(t, err.Error(), "test index %d", index)
+		}
+	}
+}
+
+//创建交易
+func testCreateMultiSigAccCreateCmd(t *testing.T, jrpc *jsonclient.JSONClient) error {
+	params := &mty.MultiSigAccCreate{}
+	return jrpc.Call("multisig.MultiSigAccCreateTx", params, nil)
+}
+func testCreateMultiSigAccOwnerAddCmd(t *testing.T, jrpc *jsonclient.JSONClient) error {
+	params := &mty.MultiSigOwnerOperate{}
+	return jrpc.Call("multisig.MultiSigOwnerOperateTx", params, nil)
+}
+func testCreateMultiSigAccOwnerDelCmd(t *testing.T, jrpc *jsonclient.JSONClient) error {
+	params := &mty.MultiSigOwnerOperate{}
+	return jrpc.Call("multisig.MultiSigOwnerOperateTx", params, nil)
+}
+func testCreateMultiSigAccOwnerModifyCmd(t *testing.T, jrpc *jsonclient.JSONClient) error {
+	params := &mty.MultiSigOwnerOperate{}
+	return jrpc.Call("multisig.MultiSigOwnerOperateTx", params, nil)
+}
+func testCreateMultiSigAccOwnerReplaceCmd(t *testing.T, jrpc *jsonclient.JSONClient) error {
+	params := &mty.MultiSigOwnerOperate{}
+	return jrpc.Call("multisig.MultiSigOwnerOperateTx", params, nil)
+}
+func testCreateMultiSigAccWeightModifyCmd(t *testing.T, jrpc *jsonclient.JSONClient) error {
+	params := &mty.MultiSigAccOperate{}
+	return jrpc.Call("multisig.MultiSigAccOperateTx", params, nil)
+}
+
+func testCreateMultiSigAccDailyLimitModifyCmd(t *testing.T, jrpc *jsonclient.JSONClient) error {
+	params := &mty.MultiSigAccOperate{}
+	return jrpc.Call("multisig.MultiSigAccOperateTx", params, nil)
+}
+
+func testCreateMultiSigConfirmTxCmd(t *testing.T, jrpc *jsonclient.JSONClient) error {
+	params := &mty.MultiSigConfirmTx{}
+	return jrpc.Call("multisig.MultiSigConfirmTx", params, nil)
+}
+func testCreateMultiSigAccTransferInCmd(t *testing.T, jrpc *jsonclient.JSONClient) error {
+	params := &mty.MultiSigExecTransferTo{}
+	return jrpc.Call("multisig.MultiSigAccTransferInTx", params, nil)
+}
+func testCreateMultiSigAccTransferOutCmd(t *testing.T, jrpc *jsonclient.JSONClient) error {
+	params := &mty.MultiSigExecTransferFrom{}
+	return jrpc.Call("multisig.MultiSigAccTransferOutTx", params, nil)
+}
+
+//get 多重签名账户信息
+func testGetMultiSigAccCountCmd(t *testing.T, jrpc *jsonclient.JSONClient) error {
+	params := &rpctypes.Query4Jrpc{
+		Execer:   mty.MultiSigX,
+		FuncName: "MultiSigAccCount",
+		Payload:  types.MustPBToJSON(&types.ReqNil{}),
+	}
+	var res types.Int64
+	return jrpc.Call("Chain33.Query", params, &res)
+}
+
+func testGetMultiSigAccountsCmd(t *testing.T, jrpc *jsonclient.JSONClient) error {
+	params := &rpctypes.Query4Jrpc{
+		Execer:   mty.MultiSigX,
+		FuncName: "MultiSigAccounts",
+		Payload:  types.MustPBToJSON(&mty.ReqMultiSigAccs{}),
+	}
+	var res mty.ReplyMultiSigAccs
+	return jrpc.Call("Chain33.Query", params, &res)
+}
+
+func testGetMultiSigAccountInfoCmd(t *testing.T, jrpc *jsonclient.JSONClient) error {
+	params := &rpctypes.Query4Jrpc{
+		Execer:   mty.MultiSigX,
+		FuncName: "MultiSigAccountInfo",
+		Payload:  types.MustPBToJSON(&mty.ReqMultiSigAccInfo{}),
+	}
+	var res mty.MultiSig
+	return jrpc.Call("Chain33.Query", params, &res)
+}
+
+func testGetMultiSigAccTxCountCmd(t *testing.T, jrpc *jsonclient.JSONClient) error {
+	params := &rpctypes.Query4Jrpc{
+		Execer:   mty.MultiSigX,
+		FuncName: "MultiSigAccTxCount",
+		Payload:  types.MustPBToJSON(&mty.ReqMultiSigAccInfo{}),
+	}
+	var res mty.Uint64
+	return jrpc.Call("Chain33.Query", params, &res)
+}
+
+func testGetMultiSigTxidsCmd(t *testing.T, jrpc *jsonclient.JSONClient) error {
+	params := &rpctypes.Query4Jrpc{
+		Execer:   mty.MultiSigX,
+		FuncName: "MultiSigTxids",
+		Payload:  types.MustPBToJSON(&mty.ReqMultiSigTxids{}),
+	}
+	var res mty.ReplyMultiSigTxids
+	return jrpc.Call("Chain33.Query", params, &res)
+}
+
+func testGetMultiSigTxInfoCmd(t *testing.T, jrpc *jsonclient.JSONClient) error {
+	var rep interface{}
+	var params rpctypes.Query4Jrpc
+	req := &mty.ReqMultiSigTxInfo{}
+	params.Execer = mty.MultiSigX
+	params.FuncName = "MultiSigTxInfo"
+	params.Payload = types.MustPBToJSON(req)
+	rep = &mty.MultiSigTx{}
+	return jrpc.Call("Chain33.Query", &params, rep)
+}
+
+func testGetGetMultiSigTxConfirmedWeightCmd(t *testing.T, jrpc *jsonclient.JSONClient) error {
+	var rep interface{}
+	var params rpctypes.Query4Jrpc
+	req := &mty.ReqMultiSigTxInfo{}
+	params.Execer = mty.MultiSigX
+	params.FuncName = "MultiSigTxConfirmedWeight"
+	params.Payload = types.MustPBToJSON(req)
+	rep = &mty.Uint64{}
+	return jrpc.Call("Chain33.Query", &params, rep)
+}
+
+func testGetGetMultiSigAccUnSpentTodayCmd(t *testing.T, jrpc *jsonclient.JSONClient) error {
+	var rep interface{}
+	var params rpctypes.Query4Jrpc
+	req := &mty.ReqAccAssets{}
+	req.IsAll = true
+	params.Execer = mty.MultiSigX
+	params.FuncName = "MultiSigAccUnSpentToday"
+	params.Payload = types.MustPBToJSON(req)
+	rep = &mty.ReplyUnSpentAssets{}
+	return jrpc.Call("Chain33.Query", &params, rep)
+}
+
+func testGetMultiSigAccAssetsCmd(t *testing.T, jrpc *jsonclient.JSONClient) error {
+	var rep interface{}
+	var params rpctypes.Query4Jrpc
+
+	req := &mty.ReqAccAssets{}
+	req.IsAll = true
+	params.Execer = mty.MultiSigX
+	params.FuncName = "MultiSigAccAssets"
+	params.Payload = types.MustPBToJSON(req)
+	rep = &mty.ReplyAccAssets{}
+	return jrpc.Call("Chain33.Query", &params, rep)
+}
+
+func testGetMultiSigAccAllAddressCmd(t *testing.T, jrpc *jsonclient.JSONClient) error {
+	var rep interface{}
+	var params rpctypes.Query4Jrpc
+
+	req := mty.ReqMultiSigAccInfo{
+		MultiSigAccAddr: "14jv8WB7CwNQSnh4qo9WDBgRPRBjM5LQo6",
+	}
+
+	params.Execer = mty.MultiSigX
+	params.FuncName = "MultiSigAccAllAddress"
+	params.Payload = types.MustPBToJSON(&req)
+	rep = &mty.AccAddress{}
+	return jrpc.Call("Chain33.Query", &params, rep)
+}

plugin/dapp/multisig/rpc/rpc.go

+// Copyright Fuzamei Corp. 2018 All Rights Reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package rpc
+
+import (
+	"encoding/hex"
+
+	"github.com/33cn/chain33/types"
+	mty "github.com/33cn/plugin/plugin/dapp/multisig/types"
+)
+
+// MultiSigAccCreateTx :构造创建多重签名账户的交易
+func (c *Jrpc) MultiSigAccCreateTx(param *mty.MultiSigAccCreate, result *interface{}) error {
+	if param == nil {
+		return types.ErrInvalidParam
+	}
+
+	data, err := types.CallCreateTx(types.ExecName(mty.MultiSigX), "MultiSigAccCreate", param)
+	if err != nil {
+		return err
+	}
+	*result = hex.EncodeToString(data)
+	return nil
+}
+
+// MultiSigOwnerOperateTx :构造修改多重签名账户owner属性的交易
+func (c *Jrpc) MultiSigOwnerOperateTx(param *mty.MultiSigOwnerOperate, result *interface{}) error {
+	if param == nil {
+		return types.ErrInvalidParam
+	}
+	data, err := types.CallCreateTx(types.ExecName(mty.MultiSigX), "MultiSigOwnerOperate", param)
+	if err != nil {
+		return err
+	}
+	*result = hex.EncodeToString(data)
+	return nil
+}
+
+// MultiSigAccOperateTx :构造修改多重签名账户属性的交易
+func (c *Jrpc) MultiSigAccOperateTx(param *mty.MultiSigAccOperate, result *interface{}) error {
+	if param == nil {
+		return types.ErrInvalidParam
+	}
+	data, err := types.CallCreateTx(types.ExecName(mty.MultiSigX), "MultiSigAccOperate", param)
+	if err != nil {
+		return err
+	}
+	*result = hex.EncodeToString(data)
+	return nil
+}
+
+// MultiSigConfirmTx :构造确认多重签名账户的交易
+func (c *Jrpc) MultiSigConfirmTx(param *mty.MultiSigConfirmTx, result *interface{}) error {
+	if param == nil {
+		return types.ErrInvalidParam
+	}
+	data, err := types.CallCreateTx(types.ExecName(mty.MultiSigX), "MultiSigConfirmTx", param)
+	if err != nil {
+		return err
+	}
+	*result = hex.EncodeToString(data)
+	return nil
+}
+
+// MultiSigAccTransferInTx :构造在多重签名合约中转账到多重签名账户的交易
+func (c *Jrpc) MultiSigAccTransferInTx(param *mty.MultiSigExecTransferTo, result *interface{}) error {
+	if param == nil {
+		return types.ErrInvalidParam
+	}
+	v := *param
+	data, err := types.CallCreateTx(types.ExecName(mty.MultiSigX), "MultiSigExecTransferTo", &v)
+	if err != nil {
+		return err
+	}
+	*result = hex.EncodeToString(data)
+	return nil
+}
+
+// MultiSigAccTransferOutTx :构造在多重签名合约中从多重签名账户转账的交易
+func (c *Jrpc) MultiSigAccTransferOutTx(param *mty.MultiSigExecTransferFrom, result *interface{}) error {
+	if param == nil {
+		return types.ErrInvalidParam
+	}
+	v := *param
+	data, err := types.CallCreateTx(types.ExecName(mty.MultiSigX), "MultiSigExecTransferFrom", &v)
+	if err != nil {
+		return err
+	}
+	*result = hex.EncodeToString(data)
+	return nil
+}

plugin/dapp/multisig/rpc/types.go

+// Copyright Fuzamei Corp. 2018 All Rights Reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package rpc
+
+import (
+	"github.com/33cn/chain33/rpc/types"
+)
+
+// Jrpc 申明Jrpc结构体
+type Jrpc struct {
+	cli *channelClient
+}
+
+// Grpc 申明Grpc结构体
+type Grpc struct {
+	*channelClient
+}
+
+type channelClient struct {
+	types.ChannelClient
+}
+
+// Init 初始化rpc实例
+func Init(name string, s types.RPCServer) {
+	cli := &channelClient{}
+	grpc := &Grpc{channelClient: cli}
+	cli.Init(name, s, &Jrpc{cli: cli}, grpc)
+}

plugin/dapp/multisig/types/const.go

+// Copyright Fuzamei Corp. 2018 All Rights Reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package types
+
+import (
+	"strings"
+
+	"github.com/33cn/chain33/common/log/log15"
+	"github.com/33cn/chain33/types"
+)
+
+var multisiglog = log15.New("module", "execs.multisig")
+
+// OwnerAdd : 交易操作类型
+var (
+	OwnerAdd     uint64 = 1
+	OwnerDel     uint64 = 2
+	OwnerModify  uint64 = 3
+	OwnerReplace uint64 = 4
+	//AccWeightOp 账户属性的操作
+	AccWeightOp     = true
+	AccDailyLimitOp = false
+	//OwnerOperate 多重签名交易类型：转账，owner操作，account操作
+	OwnerOperate    uint64 = 1
+	AccountOperate  uint64 = 2
+	TransferOperate uint64 = 3
+	//IsSubmit ：
+	IsSubmit  = true
+	IsConfirm = false
+
+	MultiSigX            = "multisig"
+	OneDaySecond   int64 = 24 * 3600
+	MinOwnersInit        = 2
+	MinOwnersCount       = 1  //一个多重签名的账户最少要保留一个owner
+	MaxOwnersCount       = 20 //一个多重签名的账户最多拥有20个owner
+
+	Multisiglog = log15.New("module", MultiSigX)
+)
+
+// MultiSig 交易的actionid
+const (
+	ActionMultiSigAccCreate        = 10000
+	ActionMultiSigOwnerOperate     = 10001
+	ActionMultiSigAccOperate       = 10002
+	ActionMultiSigConfirmTx        = 10003
+	ActionMultiSigExecTransferTo   = 10004
+	ActionMultiSigExecTransferFrom = 10005
+)
+
+//多重签名账户执行输出的logid
+const (
+	TyLogMultiSigAccCreate = 10000 //只输出多重签名的账户地址
+
+	TyLogMultiSigOwnerAdd     = 10001 //输出add的owner：addr和weight
+	TyLogMultiSigOwnerDel     = 10002 //输出del的owner：addr和weight
+	TyLogMultiSigOwnerModify  = 10003 //输出modify的owner：preweight以及currentweight
+	TyLogMultiSigOwnerReplace = 10004 //输出old的owner的信息：以及当前的owner信息：addr+weight
+
+	TyLogMultiSigAccWeightModify     = 10005 //输出修改前后确认权重的值：preReqWeight和curReqWeight
+	TyLogMultiSigAccDailyLimitAdd    = 10006 //输出add的DailyLimit：Symbol和DailyLimit
+	TyLogMultiSigAccDailyLimitModify = 10007 //输出modify的DailyLimit：preDailyLimit以及currentDailyLimit
+
+	TyLogMultiSigConfirmTx       = 10008 //对某笔未执行交易的确认
+	TyLogMultiSigConfirmTxRevoke = 10009 //已经确认交易的撤销只针对还未执行的交易
+
+	TyLogDailyLimitUpdate = 10010 //DailyLimit更新，DailyLimit在Submit和Confirm阶段都可能有变化
+	TyLogMultiSigTx       = 10011 //在Submit提交交易阶段才会有更新
+	TyLogTxCountUpdate    = 10012 //txcount只在在Submit阶段提交新的交易是才会增加计数
+
+)
+
+//AccAssetsResult 账户资产cli的显示，主要是amount需要转换成浮点型字符串
+type AccAssetsResult struct {
+	Execer   string `json:"execer,omitempty"`
+	Symbol   string `json:"symbol,omitempty"`
+	Currency int32  `json:"currency,omitempty"`
+	Balance  string `json:"balance,omitempty"`
+	Frozen   string `json:"frozen,omitempty"`
+	Receiver string `json:"receiver,omitempty"`
+	Addr     string `json:"addr,omitempty"`
+}
+
+//DailyLimitResult 每日限额信息的显示cli
+type DailyLimitResult struct {
+	Symbol     string `json:"symbol,omitempty"`
+	Execer     string `json:"execer,omitempty"`
+	DailyLimit string `json:"dailyLimit,omitempty"`
+	SpentToday string `json:"spent,omitempty"`
+	LastDay    string `json:"lastday,omitempty"`
+}
+
+//MultiSigResult 多重签名账户信息的显示cli
+type MultiSigResult struct {
+	CreateAddr     string              `json:"createAddr,omitempty"`
+	MultiSigAddr   string              `json:"multiSigAddr,omitempty"`
+	Owners         []*Owner            `json:"owners,omitempty"`
+	DailyLimits    []*DailyLimitResult `json:"dailyLimits,omitempty"`
+	TxCount        uint64              `json:"txCount,omitempty"`
+	RequiredWeight uint64              `json:"requiredWeight,omitempty"`
+}
+
+//UnSpentAssetsResult 每日限额之内未花费额度的显示cli
+type UnSpentAssetsResult struct {
+	Symbol  string `json:"symbol,omitempty"`
+	Execer  string `json:"execer,omitempty"`
+	UnSpent string `json:"unspent,omitempty"`
+}
+
+//IsAssetsInvalid 资产的合法性检测，Symbol：必须全部大写，例如：BTY,coins.BTY。exec：必须在types.AllowUserExec中存在
+func IsAssetsInvalid(exec, symbol string) error {
+
+	//exec检测
+	allowExeName := types.AllowUserExec
+	nameLen := len(allowExeName)
+	execValid := false
+	for i := 0; i < nameLen; i++ {
+		if exec == string(allowExeName[i]) {
+			execValid = true
+			break
+		}
+	}
+	if !execValid {
+		multisiglog.Error("IsAssetsInvalid", "exec", exec)
+		return ErrInvalidExec
+	}
+	//Symbol检测
+	symbolstr := strings.Split(symbol, ".")[len(strings.Split(symbol, "."))-1]
+	valid := validSymbol([]byte(symbolstr))
+	if !valid {
+		multisiglog.Error("IsAssetsInvalid", "symbol", symbol)
+		return ErrInvalidSymbol
+	}
+	return nil
+}
+
+func isUpperChar(a byte) bool {
+	res := (a <= 'Z' && a >= 'A')
+	return res
+}
+
+func validSymbol(cs []byte) bool {
+	for _, c := range cs {
+		if !isUpperChar(c) {
+			return false
+		}
+	}
+	return true
+}

plugin/dapp/multisig/types/errors.go

+// Copyright Fuzamei Corp. 2018 All Rights Reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package types
+
+import "errors"
+
+//multisig 合约的错误码
+var (
+	ErrRequiredweight       = errors.New("ErrRequiredweight")
+	ErrCreatAccountAddr     = errors.New("ErrCreatAccountAddr")
+	ErrOwnerExist           = errors.New("ErrOwnerExist")
+	ErrOwnerNotExist        = errors.New("ErrOwnerNotExist")
+	ErrTotalWeightNotEnough = errors.New("ErrTotalWeightNotEnough")
+	ErrIsNotOwner           = errors.New("ErrIsNotOwner")
+	ErrDailyLimitIsZero     = errors.New("ErrDailyLimitIsZero")
+	ErrInvalidTxid          = errors.New("ErrInvalidTxid")
+	ErrTxidNotExist         = errors.New("ErrTxidNotExist")
+	ErrTxHasExecuted        = errors.New("ErrTxHasExecuted")
+	ErrDupConfirmed         = errors.New("ErrDupConfirmed")
+	ErrConfirmNotExist      = errors.New("ErrConfirmNotExist")
+	ErrExecerHashNoMatch    = errors.New("ErrExecerHashNoMatch")
+	ErrPayLoadTypeNoMatch   = errors.New("ErrPayLoadTypeNoMatch")
+	ErrTxHashNoMatch        = errors.New("ErrTxHashNoMatch")
+	ErrAccCountNoMatch      = errors.New("ErrAccCountNoMatch")
+	ErrAccountHasExist      = errors.New("ErrAccountHasExist")
+	ErrOwnerNoMatch         = errors.New("ErrOwnerNoMatch")
+	ErrDailyLimitNoMatch    = errors.New("ErrDailyLimitNoMatch")
+	ErrExecutedNoMatch      = errors.New("ErrExecutedNoMatch")
+	ErrActionTyNoMatch      = errors.New("ErrActionTyNoMatch")
+	ErrTxTypeNoMatch        = errors.New("ErrTxTypeNoMatch")
+	ErrTxidHasExist         = errors.New("ErrTxidHasExist")
+	ErrOnlyOneOwner         = errors.New("ErrOnlyOneOwner")
+	ErrOperateType          = errors.New("ErrOperateType")
+	ErrNewOwnerExist        = errors.New("ErrNewOwnerExist")
+	ErrOwnerLessThanTwo     = errors.New("ErrOwnerLessThanTwo")
+	ErrAddrNotSupport       = errors.New("ErrAddrNotSupport")
+	ErrMaxOwnerCount        = errors.New("ErrMaxOwnerCount")
+	ErrInvalidSymbol        = errors.New("ErrInvalidSymbol")
+	ErrInvalidExec          = errors.New("ErrInvalidExec")
+	ErrInvalidWeight        = errors.New("ErrInvalidWeight")
+	ErrInvalidDailyLimit    = errors.New("ErrInvalidDailyLimit")
+)

plugin/dapp/multisig/types/multisig.pb.go

+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: multisig.proto
+
+package types
+
+import (
+	fmt "fmt"
+	math "math"
+
+	types "github.com/33cn/chain33/types"
+	proto "github.com/golang/protobuf/proto"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+//////////////////////////////////////////////////////////////////////////////
+// message for multisig start/////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////
+//多重签名账户的状态信息，存在在statedb中，通过多重签名账户作为key值
+//createaddr: 创建多重签名地址的创建者账户
+//multisigaddr: 多重签名地址
+//owners: 可以操作此多重签名地址的owner账户列表
+//DailyLimit: 不同资产的每日限额，通过symbol来区分，本连的原生币，以及跨链过来的其他链的原生币
+//txCount:记录此多重签名地址上提交的withdraw交易数
+//requiredweight:确认一笔withdraw交易需要的权重。
+type MultiSig struct {
+	CreateAddr           string        `protobuf:"bytes,1,opt,name=createAddr,proto3" json:"createAddr,omitempty"`
+	MultiSigAddr         string        `protobuf:"bytes,2,opt,name=multiSigAddr,proto3" json:"multiSigAddr,omitempty"`
+	Owners               []*Owner      `protobuf:"bytes,3,rep,name=owners,proto3" json:"owners,omitempty"`
+	DailyLimits          []*DailyLimit `protobuf:"bytes,4,rep,name=dailyLimits,proto3" json:"dailyLimits,omitempty"`
+	TxCount              uint64        `protobuf:"varint,5,opt,name=txCount,proto3" json:"txCount,omitempty"`
+	RequiredWeight       uint64        `protobuf:"varint,6,opt,name=requiredWeight,proto3" json:"requiredWeight,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
+	XXX_unrecognized     []byte        `json:"-"`
+	XXX_sizecache        int32         `json:"-"`
+}
+
+func (m *MultiSig) Reset()         { *m = MultiSig{} }
+func (m *MultiSig) String() string { return proto.CompactTextString(m) }
+func (*MultiSig) ProtoMessage()    {}
+func (*MultiSig) Descriptor() ([]byte, []int) {
+	return fileDescriptor_62b8b91adf3febfa, []int{0}
+}
+
+func (m *MultiSig) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_MultiSig.Unmarshal(m, b)
+}
+func (m *MultiSig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_MultiSig.Marshal(b, m, deterministic)
+}
+func (m *MultiSig) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_MultiSig.Merge(m, src)
+}
+func (m *MultiSig) XXX_Size() int {
+	return xxx_messageInfo_MultiSig.Size(m)
+}
+func (m *MultiSig) XXX_DiscardUnknown() {
+	xxx_messageInfo_MultiSig.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MultiSig proto.InternalMessageInfo
+
+func (m *MultiSig) GetCreateAddr() string {
+	if m != nil {
+		return m.CreateAddr
+	}
+	return ""
+}
+
+func (m *MultiSig) GetMultiSigAddr() string {
+	if m != nil {
+		return m.MultiSigAddr
+	}
+	return ""
+}
+
+func (m *MultiSig) GetOwners() []*Owner {
+	if m != nil {
+		return m.Owners
+	}
+	return nil
+}
+
+func (m *MultiSig) GetDailyLimits() []*DailyLimit {
+	if m != nil {
+		return m.DailyLimits
+	}
+	return nil
+}
+
+func (m *MultiSig) GetTxCount() uint64 {
+	if m != nil {
+		return m.TxCount
+	}
+	return 0
+}
+
+func (m *MultiSig) GetRequiredWeight() uint64 {
+	if m != nil {
+		return m.RequiredWeight
+	}
+	return 0
+}
+
+//这个地址是否已经确认某个交易
+type ConfirmedOwner struct {
+	ConfirmedOwner       []*Owner `protobuf:"bytes,1,rep,name=confirmedOwner,proto3" json:"confirmedOwner,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *ConfirmedOwner) Reset()         { *m = ConfirmedOwner{} }
+func (m *ConfirmedOwner) String() string { return proto.CompactTextString(m) }
+func (*ConfirmedOwner) ProtoMessage()    {}
+func (*ConfirmedOwner) Descriptor() ([]byte, []int) {
+	return fileDescriptor_62b8b91adf3febfa, []int{1}
+}
+
+func (m *ConfirmedOwner) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_ConfirmedOwner.Unmarshal(m, b)
+}
+func (m *ConfirmedOwner) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_ConfirmedOwner.Marshal(b, m, deterministic)
+}
+func (m *ConfirmedOwner) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ConfirmedOwner.Merge(m, src)
+}
+func (m *ConfirmedOwner) XXX_Size() int {
+	return xxx_messageInfo_ConfirmedOwner.Size(m)
+}
+func (m *ConfirmedOwner) XXX_DiscardUnknown() {
+	xxx_messageInfo_ConfirmedOwner.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ConfirmedOwner proto.InternalMessageInfo
+
+func (m *ConfirmedOwner) GetConfirmedOwner() []*Owner {
+	if m != nil {
+		return m.ConfirmedOwner
+	}
+	return nil
+}
+
+//记录提交的交易详情，在满足确认条件后执行data中的交易
+//txHash:用于存贮提交的确认交易。存贮在localdb中，通过txhash可以获取
+type MultiSigTx struct {
+	Txid                 uint64   `protobuf:"varint,1,opt,name=txid,proto3" json:"txid,omitempty"`
+	TxHash               string   `protobuf:"bytes,2,opt,name=txHash,proto3" json:"txHash,omitempty"`
+	Executed             bool     `protobuf:"varint,3,opt,name=executed,proto3" json:"executed,omitempty"`
+	TxType               uint64   `protobuf:"varint,4,opt,name=txType,proto3" json:"txType,omitempty"`
+	MultiSigAddr         string   `protobuf:"bytes,5,opt,name=multiSigAddr,proto3" json:"multiSigAddr,omitempty"`
+	ConfirmedOwner       []*Owner `protobuf:"bytes,6,rep,name=confirmedOwner,proto3" json:"confirmedOwner,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *MultiSigTx) Reset()         { *m = MultiSigTx{} }
+func (m *MultiSigTx) String() string { return proto.CompactTextString(m) }
+func (*MultiSigTx) ProtoMessage()    {}
+func (*MultiSigTx) Descriptor() ([]byte, []int) {
+	return fileDescriptor_62b8b91adf3febfa, []int{2}
+}
+
+func (m *MultiSigTx) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_MultiSigTx.Unmarshal(m, b)
+}
+func (m *MultiSigTx) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_MultiSigTx.Marshal(b, m, deterministic)
+}
+func (m *MultiSigTx) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_MultiSigTx.Merge(m, src)
+}
+func (m *MultiSigTx) XXX_Size() int {
+	return xxx_messageInfo_MultiSigTx.Size(m)
+}
+func (m *MultiSigTx) XXX_DiscardUnknown() {
+	xxx_messageInfo_MultiSigTx.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MultiSigTx proto.InternalMessageInfo
+
+func (m *MultiSigTx) GetTxid() uint64 {
+	if m != nil {
+		return m.Txid
+	}
+	return 0
+}
+
+func (m *MultiSigTx) GetTxHash() string {
+	if m != nil {
+		return m.TxHash
+	}
+	return ""
+}
+
+func (m *MultiSigTx) GetExecuted() bool {
+	if m != nil {
+		return m.Executed
+	}
+	return false
+}
+
+func (m *MultiSigTx) GetTxType() uint64 {
+	if m != nil {
+		return m.TxType
+	}
+	return 0
+}
+
+func (m *MultiSigTx) GetMultiSigAddr() string {
+	if m != nil {
+		return m.MultiSigAddr
+	}
+	return ""
+}
+
+func (m *MultiSigTx) GetConfirmedOwner() []*Owner {
+	if m != nil {
+		return m.ConfirmedOwner
+	}
+	return nil
+}
+
+// owner 结构体：owner账户地址，以及权重
+type Owner struct {
+	OwnerAddr            string   `protobuf:"bytes,1,opt,name=ownerAddr,proto3" json:"ownerAddr,omitempty"`
+	Weight               uint64   `protobuf:"varint,2,opt,name=weight,proto3" json:"weight,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *Owner) Reset()         { *m = Owner{} }
+func (m *Owner) String() string { return proto.CompactTextString(m) }
+func (*Owner) ProtoMessage()    {}
+func (*Owner) Descriptor() ([]byte, []int) {
+	return fileDescriptor_62b8b91adf3febfa, []int{3}
+}
+
+func (m *Owner) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Owner.Unmarshal(m, b)
+}
+func (m *Owner) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Owner.Marshal(b, m, deterministic)
+}
+func (m *Owner) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Owner.Merge(m, src)
+}
+func (m *Owner) XXX_Size() int {
+	return xxx_messageInfo_Owner.Size(m)
+}
+func (m *Owner) XXX_DiscardUnknown() {
+	xxx_messageInfo_Owner.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Owner proto.InternalMessageInfo
+
+func (m *Owner) GetOwnerAddr() string {
+	if m != nil {
+		return m.OwnerAddr
+	}
+	return ""
+}
+
+func (m *Owner) GetWeight() uint64 {
+	if m != nil {
+		return m.Weight
+	}
+	return 0
+}
+
+//每日资产限额，不同的资产价格不一致，需要设置各自的每日限额。没有设置或者限额是0时，表示不能取币
+//spentToday今天已经花费的额度。用于和dailyLimit做对比，超过每日限额时需要多重签名
+//lastDay记录当天开始的时间戳，新的一天需要重置spentToday为初始值0，并修改lastDay的时间戳
+type DailyLimit struct {
+	Symbol               string   `protobuf:"bytes,1,opt,name=symbol,proto3" json:"symbol,omitempty"`
+	Execer               string   `protobuf:"bytes,2,opt,name=execer,proto3" json:"execer,omitempty"`
+	DailyLimit           uint64   `protobuf:"varint,3,opt,name=dailyLimit,proto3" json:"dailyLimit,omitempty"`
+	SpentToday           uint64   `protobuf:"varint,4,opt,name=spentToday,proto3" json:"spentToday,omitempty"`
+	LastDay              int64    `protobuf:"varint,5,opt,name=lastDay,proto3" json:"lastDay,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *DailyLimit) Reset()         { *m = DailyLimit{} }
+func (m *DailyLimit) String() string { return proto.CompactTextString(m) }
+func (*DailyLimit) ProtoMessage()    {}
+func (*DailyLimit) Descriptor() ([]byte, []int) {
+	return fileDescriptor_62b8b91adf3febfa, []int{4}
+}
+
+func (m *DailyLimit) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_DailyLimit.Unmarshal(m, b)
+}
+func (m *DailyLimit) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_DailyLimit.Marshal(b, m, deterministic)
+}
+func (m *DailyLimit) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_DailyLimit.Merge(m, src)
+}
+func (m *DailyLimit) XXX_Size() int {
+	return xxx_messageInfo_DailyLimit.Size(m)
+}
+func (m *DailyLimit) XXX_DiscardUnknown() {
+	xxx_messageInfo_DailyLimit.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_DailyLimit proto.InternalMessageInfo
+
+func (m *DailyLimit) GetSymbol() string {
+	if m != nil {
+		return m.Symbol
+	}
+	return ""
+}
+
+func (m *DailyLimit) GetExecer() string {
+	if m != nil {
+		return m.Execer
+	}
+	return ""
+}
+
+func (m *DailyLimit) GetDailyLimit() uint64 {
+	if m != nil {
+		return m.DailyLimit
+	}
+	return 0
+}
+
+func (m *DailyLimit) GetSpentToday() uint64 {
+	if m != nil {
+		return m.SpentToday
+	}
+	return 0
+}
+
+func (m *DailyLimit) GetLastDay() int64 {
+	if m != nil {
+		return m.LastDay
+	}
+	return 0
+}
+
+type SymbolDailyLimit struct {
+	Symbol               string   `protobuf:"bytes,1,opt,name=symbol,proto3" json:"symbol,omitempty"`
+	Execer               string   `protobuf:"bytes,2,opt,name=execer,proto3" json:"execer,omitempty"`
+	DailyLimit           uint64   `protobuf:"varint,3,opt,name=dailyLimit,proto3" json:"dailyLimit,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *SymbolDailyLimit) Reset()         { *m = SymbolDailyLimit{} }
+func (m *SymbolDailyLimit) String() string { return proto.CompactTextString(m) }
+func (*SymbolDailyLimit) ProtoMessage()    {}
+func (*SymbolDailyLimit) Descriptor() ([]byte, []int) {
+	return fileDescriptor_62b8b91adf3febfa, []int{5}
+}
+
+func (m *SymbolDailyLimit) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_SymbolDailyLimit.Unmarshal(m, b)
+}
+func (m *SymbolDailyLimit) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_SymbolDailyLimit.Marshal(b, m, deterministic)
+}
+func (m *SymbolDailyLimit) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_SymbolDailyLimit.Merge(m, src)
+}
+func (m *SymbolDailyLimit) XXX_Size() int {
+	return xxx_messageInfo_SymbolDailyLimit.Size(m)
+}
+func (m *SymbolDailyLimit) XXX_DiscardUnknown() {
+	xxx_messageInfo_SymbolDailyLimit.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_SymbolDailyLimit proto.InternalMessageInfo
+
+func (m *SymbolDailyLimit) GetSymbol() string {
+	if m != nil {
+		return m.Symbol
+	}
+	return ""
+}
+
+func (m *SymbolDailyLimit) GetExecer() string {
+	if m != nil {
+		return m.Execer
+	}
+	return ""
+}
+
+func (m *SymbolDailyLimit) GetDailyLimit() uint64 {
+	if m != nil {
+		return m.DailyLimit
+	}
+	return 0
+}
+
+//MultiSig 所有可能的交易action
+type MultiSigAction struct {
+	// Types that are valid to be assigned to Value:
+	//	*MultiSigAction_MultiSigAccCreate
+	//	*MultiSigAction_MultiSigOwnerOperate
+	//	*MultiSigAction_MultiSigAccOperate
+	//	*MultiSigAction_MultiSigConfirmTx
+	//	*MultiSigAction_MultiSigExecTransferTo
+	//	*MultiSigAction_MultiSigExecTransferFrom
+	Value                isMultiSigAction_Value `protobuf_oneof:"value"`
+	Ty                   int32                  `protobuf:"varint,7,opt,name=Ty,proto3" json:"Ty,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
+	XXX_unrecognized     []byte                 `json:"-"`
+	XXX_sizecache        int32                  `json:"-"`
+}
+
+func (m *MultiSigAction) Reset()         { *m = MultiSigAction{} }
+func (m *MultiSigAction) String() string { return proto.CompactTextString(m) }
+func (*MultiSigAction) ProtoMessage()    {}
+func (*MultiSigAction) Descriptor() ([]byte, []int) {
+	return fileDescriptor_62b8b91adf3febfa, []int{6}
+}
+
+func (m *MultiSigAction) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_MultiSigAction.Unmarshal(m, b)
+}
+func (m *MultiSigAction) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_MultiSigAction.Marshal(b, m, deterministic)
+}
+func (m *MultiSigAction) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_MultiSigAction.Merge(m, src)
+}
+func (m *MultiSigAction) XXX_Size() int {
+	return xxx_messageInfo_MultiSigAction.Size(m)
+}
+func (m *MultiSigAction) XXX_DiscardUnknown() {
+	xxx_messageInfo_MultiSigAction.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MultiSigAction proto.InternalMessageInfo
+
+type isMultiSigAction_Value interface {
+	isMultiSigAction_Value()
+}
+
+type MultiSigAction_MultiSigAccCreate struct {
+	MultiSigAccCreate *MultiSigAccCreate `protobuf:"bytes,1,opt,name=multiSigAccCreate,proto3,oneof"`
+}
+
+type MultiSigAction_MultiSigOwnerOperate struct {
+	MultiSigOwnerOperate *MultiSigOwnerOperate `protobuf:"bytes,2,opt,name=multiSigOwnerOperate,proto3,oneof"`
+}
+
+type MultiSigAction_MultiSigAccOperate struct {
+	MultiSigAccOperate *MultiSigAccOperate `protobuf:"bytes,3,opt,name=multiSigAccOperate,proto3,oneof"`
+}
+
+type MultiSigAction_MultiSigConfirmTx struct {
+	MultiSigConfirmTx *MultiSigConfirmTx `protobuf:"bytes,4,opt,name=multiSigConfirmTx,proto3,oneof"`
+}
+
+type MultiSigAction_MultiSigExecTransferTo struct {
+	MultiSigExecTransferTo *MultiSigExecTransferTo `protobuf:"bytes,5,opt,name=multiSigExecTransferTo,proto3,oneof"`
+}
+
+type MultiSigAction_MultiSigExecTransferFrom struct {
+	MultiSigExecTransferFrom *MultiSigExecTransferFrom `protobuf:"bytes,6,opt,name=multiSigExecTransferFrom,proto3,oneof"`
+}
+
+func (*MultiSigAction_MultiSigAccCreate) isMultiSigAction_Value() {}
+
+func (*MultiSigAction_MultiSigOwnerOperate) isMultiSigAction_Value() {}
+
+func (*MultiSigAction_MultiSigAccOperate) isMultiSigAction_Value() {}
+
+func (*MultiSigAction_MultiSigConfirmTx) isMultiSigAction_Value() {}
+
+func (*MultiSigAction_MultiSigExecTransferTo) isMultiSigAction_Value() {}
+
+func (*MultiSigAction_MultiSigExecTransferFrom) isMultiSigAction_Value() {}
+
+func (m *MultiSigAction) GetValue() isMultiSigAction_Value {
+	if m != nil {
+		return m.Value
+	}
+	return nil
+}
+
+func (m *MultiSigAction) GetMultiSigAccCreate() *MultiSigAccCreate {
+	if x, ok := m.GetValue().(*MultiSigAction_MultiSigAccCreate); ok {
+		return x.MultiSigAccCreate
+	}
+	return nil
+}
+
+func (m *MultiSigAction) GetMultiSigOwnerOperate() *MultiSigOwnerOperate {
+	if x, ok := m.GetValue().(*MultiSigAction_MultiSigOwnerOperate); ok {
+		return x.MultiSigOwnerOperate
+	}
+	return nil
+}
+
+func (m *MultiSigAction) GetMultiSigAccOperate() *MultiSigAccOperate {
+	if x, ok := m.GetValue().(*MultiSigAction_MultiSigAccOperate); ok {
+		return x.MultiSigAccOperate
+	}
+	return nil
+}
+
+func (m *MultiSigAction) GetMultiSigConfirmTx() *MultiSigConfirmTx {
+	if x, ok := m.GetValue().(*MultiSigAction_MultiSigConfirmTx); ok {
+		return x.MultiSigConfirmTx
+	}
+	return nil
+}
+
+func (m *MultiSigAction) GetMultiSigExecTransferTo() *MultiSigExecTransferTo {
+	if x, ok := m.GetValue().(*MultiSigAction_MultiSigExecTransferTo); ok {
+		return x.MultiSigExecTransferTo
+	}
+	return nil
+}
+
+func (m *MultiSigAction) GetMultiSigExecTransferFrom() *MultiSigExecTransferFrom {
+	if x, ok := m.GetValue().(*MultiSigAction_MultiSigExecTransferFrom); ok {
+		return x.MultiSigExecTransferFrom
+	}
+	return nil
+}
+
+func (m *MultiSigAction) GetTy() int32 {
+	if m != nil {
+		return m.Ty
+	}
+	return 0
+}
+
+// XXX_OneofFuncs is for the internal use of the proto package.
+func (*MultiSigAction) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
+	return _MultiSigAction_OneofMarshaler, _MultiSigAction_OneofUnmarshaler, _MultiSigAction_OneofSizer, []interface{}{
+		(*MultiSigAction_MultiSigAccCreate)(nil),
+		(*MultiSigAction_MultiSigOwnerOperate)(nil),
+		(*MultiSigAction_MultiSigAccOperate)(nil),
+		(*MultiSigAction_MultiSigConfirmTx)(nil),
+		(*MultiSigAction_MultiSigExecTransferTo)(nil),
+		(*MultiSigAction_MultiSigExecTransferFrom)(nil),
+	}
+}
+
+func _MultiSigAction_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
+	m := msg.(*MultiSigAction)
+	// value
+	switch x := m.Value.(type) {
+	case *MultiSigAction_MultiSigAccCreate:
+		b.EncodeVarint(1<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.MultiSigAccCreate); err != nil {
+			return err
+		}
+	case *MultiSigAction_MultiSigOwnerOperate:
+		b.EncodeVarint(2<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.MultiSigOwnerOperate); err != nil {
+			return err
+		}
+	case *MultiSigAction_MultiSigAccOperate:
+		b.EncodeVarint(3<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.MultiSigAccOperate); err != nil {
+			return err
+		}
+	case *MultiSigAction_MultiSigConfirmTx:
+		b.EncodeVarint(4<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.MultiSigConfirmTx); err != nil {
+			return err
+		}
+	case *MultiSigAction_MultiSigExecTransferTo:
+		b.EncodeVarint(5<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.MultiSigExecTransferTo); err != nil {
+			return err
+		}
+	case *MultiSigAction_MultiSigExecTransferFrom:
+		b.EncodeVarint(6<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.MultiSigExecTransferFrom); err != nil {
+			return err
+		}
+	case nil:
+	default:
+		return fmt.Errorf("MultiSigAction.Value has unexpected type %T", x)
+	}
+	return nil
+}
+
+func _MultiSigAction_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
+	m := msg.(*MultiSigAction)
+	switch tag {
+	case 1: // value.multiSigAccCreate
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(MultiSigAccCreate)
+		err := b.DecodeMessage(msg)
+		m.Value = &MultiSigAction_MultiSigAccCreate{msg}
+		return true, err
+	case 2: // value.multiSigOwnerOperate
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(MultiSigOwnerOperate)
+		err := b.DecodeMessage(msg)
+		m.Value = &MultiSigAction_MultiSigOwnerOperate{msg}
+		return true, err
+	case 3: // value.multiSigAccOperate
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(MultiSigAccOperate)
+		err := b.DecodeMessage(msg)
+		m.Value = &MultiSigAction_MultiSigAccOperate{msg}
+		return true, err
+	case 4: // value.multiSigConfirmTx
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(MultiSigConfirmTx)
+		err := b.DecodeMessage(msg)
+		m.Value = &MultiSigAction_MultiSigConfirmTx{msg}
+		return true, err
+	case 5: // value.multiSigExecTransferTo
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(MultiSigExecTransferTo)
+		err := b.DecodeMessage(msg)
+		m.Value = &MultiSigAction_MultiSigExecTransferTo{msg}
+		return true, err
+	case 6: // value.multiSigExecTransferFrom
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(MultiSigExecTransferFrom)
+		err := b.DecodeMessage(msg)
+		m.Value = &MultiSigAction_MultiSigExecTransferFrom{msg}
+		return true, err
+	default:
+		return false, nil
+	}
+}
+
+func _MultiSigAction_OneofSizer(msg proto.Message) (n int) {
+	m := msg.(*MultiSigAction)
+	// value
+	switch x := m.Value.(type) {
+	case *MultiSigAction_MultiSigAccCreate:
+		s := proto.Size(x.MultiSigAccCreate)
+		n += 1 // tag and wire
+		n += proto.SizeVarint(uint64(s))
+		n += s
+	case *MultiSigAction_MultiSigOwnerOperate:
+		s := proto.Size(x.MultiSigOwnerOperate)
+		n += 1 // tag and wire
+		n += proto.SizeVarint(uint64(s))
+		n += s
+	case *MultiSigAction_MultiSigAccOperate:
+		s := proto.Size(x.MultiSigAccOperate)
+		n += 1 // tag and wire
+		n += proto.SizeVarint(uint64(s))
+		n += s
+	case *MultiSigAction_MultiSigConfirmTx:
+		s := proto.Size(x.MultiSigConfirmTx)
+		n += 1 // tag and wire
+		n += proto.SizeVarint(uint64(s))
+		n += s
+	case *MultiSigAction_MultiSigExecTransferTo:
+		s := proto.Size(x.MultiSigExecTransferTo)
+		n += 1 // tag and wire
+		n += proto.SizeVarint(uint64(s))
+		n += s
+	case *MultiSigAction_MultiSigExecTransferFrom:
+		s := proto.Size(x.MultiSigExecTransferFrom)
+		n += 1 // tag and wire
+		n += proto.SizeVarint(uint64(s))
+		n += s
+	case nil:
+	default:
+		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
+	}
+	return n
+}
+
+//创建多重签名账户时需要的信息：创建时最少初始化两个owners，资产的每日限额初始时可以不设置
+type MultiSigAccCreate struct {
+	Owners               []*Owner          `protobuf:"bytes,1,rep,name=owners,proto3" json:"owners,omitempty"`
+	RequiredWeight       uint64            `protobuf:"varint,2,opt,name=requiredWeight,proto3" json:"requiredWeight,omitempty"`
+	DailyLimit           *SymbolDailyLimit `protobuf:"bytes,3,opt,name=dailyLimit,proto3" json:"dailyLimit,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
+	XXX_unrecognized     []byte            `json:"-"`
+	XXX_sizecache        int32             `json:"-"`
+}
+
+func (m *MultiSigAccCreate) Reset()         { *m = MultiSigAccCreate{} }
+func (m *MultiSigAccCreate) String() string { return proto.CompactTextString(m) }
+func (*MultiSigAccCreate) ProtoMessage()    {}
+func (*MultiSigAccCreate) Descriptor() ([]byte, []int) {
+	return fileDescriptor_62b8b91adf3febfa, []int{7}
+}
+
+func (m *MultiSigAccCreate) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_MultiSigAccCreate.Unmarshal(m, b)
+}
+func (m *MultiSigAccCreate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_MultiSigAccCreate.Marshal(b, m, deterministic)
+}
+func (m *MultiSigAccCreate) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_MultiSigAccCreate.Merge(m, src)
+}
+func (m *MultiSigAccCreate) XXX_Size() int {
+	return xxx_messageInfo_MultiSigAccCreate.Size(m)
+}
+func (m *MultiSigAccCreate) XXX_DiscardUnknown() {
+	xxx_messageInfo_MultiSigAccCreate.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MultiSigAccCreate proto.InternalMessageInfo
+
+func (m *MultiSigAccCreate) GetOwners() []*Owner {
+	if m != nil {
+		return m.Owners
+	}
+	return nil
+}
+
+func (m *MultiSigAccCreate) GetRequiredWeight() uint64 {
+	if m != nil {
+		return m.RequiredWeight
+	}
+	return 0
+}
+
+func (m *MultiSigAccCreate) GetDailyLimit() *SymbolDailyLimit {
+	if m != nil {
+		return m.DailyLimit
+	}
+	return nil
+}
+
+//对MultiSigAccount账户owner的操作：add/del/replace/modify
+type MultiSigOwnerOperate struct {
+	MultiSigAccAddr      string   `protobuf:"bytes,1,opt,name=multiSigAccAddr,proto3" json:"multiSigAccAddr,omitempty"`
+	OldOwner             string   `protobuf:"bytes,2,opt,name=oldOwner,proto3" json:"oldOwner,omitempty"`
+	NewOwner             string   `protobuf:"bytes,3,opt,name=newOwner,proto3" json:"newOwner,omitempty"`
+	NewWeight            uint64   `protobuf:"varint,4,opt,name=newWeight,proto3" json:"newWeight,omitempty"`
+	OperateFlag          uint64   `protobuf:"varint,5,opt,name=operateFlag,proto3" json:"operateFlag,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *MultiSigOwnerOperate) Reset()         { *m = MultiSigOwnerOperate{} }
+func (m *MultiSigOwnerOperate) String() string { return proto.CompactTextString(m) }
+func (*MultiSigOwnerOperate) ProtoMessage()    {}
+func (*MultiSigOwnerOperate) Descriptor() ([]byte, []int) {
+	return fileDescriptor_62b8b91adf3febfa, []int{8}
+}
+
+func (m *MultiSigOwnerOperate) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_MultiSigOwnerOperate.Unmarshal(m, b)
+}
+func (m *MultiSigOwnerOperate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_MultiSigOwnerOperate.Marshal(b, m, deterministic)
+}
+func (m *MultiSigOwnerOperate) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_MultiSigOwnerOperate.Merge(m, src)
+}
+func (m *MultiSigOwnerOperate) XXX_Size() int {
+	return xxx_messageInfo_MultiSigOwnerOperate.Size(m)
+}
+func (m *MultiSigOwnerOperate) XXX_DiscardUnknown() {
+	xxx_messageInfo_MultiSigOwnerOperate.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MultiSigOwnerOperate proto.InternalMessageInfo
+
+func (m *MultiSigOwnerOperate) GetMultiSigAccAddr() string {
+	if m != nil {
+		return m.MultiSigAccAddr
+	}
+	return ""
+}
+
+func (m *MultiSigOwnerOperate) GetOldOwner() string {
+	if m != nil {
+		return m.OldOwner
+	}
+	return ""
+}
+
+func (m *MultiSigOwnerOperate) GetNewOwner() string {
+	if m != nil {
+		return m.NewOwner
+	}
+	return ""
+}
+
+func (m *MultiSigOwnerOperate) GetNewWeight() uint64 {
+	if m != nil {
+		return m.NewWeight
+	}
+	return 0
+}
+
+func (m *MultiSigOwnerOperate) GetOperateFlag() uint64 {
+	if m != nil {
+		return m.OperateFlag
+	}
+	return 0
+}
+
+//对MultiSigAccount账户的操作：modify/add:SymbolDailyLimit,requiredweight
+//修改或者添加每日限额，或者请求权重的值。
+type MultiSigAccOperate struct {
+	MultiSigAccAddr      string            `protobuf:"bytes,1,opt,name=multiSigAccAddr,proto3" json:"multiSigAccAddr,omitempty"`
+	DailyLimit           *SymbolDailyLimit `protobuf:"bytes,2,opt,name=dailyLimit,proto3" json:"dailyLimit,omitempty"`
+	NewRequiredWeight    uint64            `protobuf:"varint,3,opt,name=newRequiredWeight,proto3" json:"newRequiredWeight,omitempty"`
+	OperateFlag          bool              `protobuf:"varint,4,opt,name=operateFlag,proto3" json:"operateFlag,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
+	XXX_unrecognized     []byte            `json:"-"`
+	XXX_sizecache        int32             `json:"-"`
+}
+
+func (m *MultiSigAccOperate) Reset()         { *m = MultiSigAccOperate{} }
+func (m *MultiSigAccOperate) String() string { return proto.CompactTextString(m) }
+func (*MultiSigAccOperate) ProtoMessage()    {}
+func (*MultiSigAccOperate) Descriptor() ([]byte, []int) {
+	return fileDescriptor_62b8b91adf3febfa, []int{9}
+}
+
+func (m *MultiSigAccOperate) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_MultiSigAccOperate.Unmarshal(m, b)
+}
+func (m *MultiSigAccOperate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_MultiSigAccOperate.Marshal(b, m, deterministic)
+}
+func (m *MultiSigAccOperate) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_MultiSigAccOperate.Merge(m, src)
+}
+func (m *MultiSigAccOperate) XXX_Size() int {
+	return xxx_messageInfo_MultiSigAccOperate.Size(m)
+}
+func (m *MultiSigAccOperate) XXX_DiscardUnknown() {
+	xxx_messageInfo_MultiSigAccOperate.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MultiSigAccOperate proto.InternalMessageInfo
+
+func (m *MultiSigAccOperate) GetMultiSigAccAddr() string {
+	if m != nil {
+		return m.MultiSigAccAddr
+	}
+	return ""
+}
+
+func (m *MultiSigAccOperate) GetDailyLimit() *SymbolDailyLimit {
+	if m != nil {
+		return m.DailyLimit
+	}
+	return nil
+}
+
+func (m *MultiSigAccOperate) GetNewRequiredWeight() uint64 {
+	if m != nil {
+		return m.NewRequiredWeight
+	}
+	return 0
+}
+
+func (m *MultiSigAccOperate) GetOperateFlag() bool {
+	if m != nil {
+		return m.OperateFlag
+	}
+	return false
+}
+
+//多重签名合约中账户之间转币操作:增加一个from的字段实现MultiSigAddr--->addr之间的转账
+//需要判断from地址是否是多重签名地址
+//将MultiSig合约中from地址上execname+symbol的资产转移到to地址
+type MultiSigExecTransferFrom struct {
+	Symbol               string   `protobuf:"bytes,1,opt,name=symbol,proto3" json:"symbol,omitempty"`
+	Amount               int64    `protobuf:"varint,2,opt,name=amount,proto3" json:"amount,omitempty"`
+	Note                 string   `protobuf:"bytes,3,opt,name=note,proto3" json:"note,omitempty"`
+	Execname             string   `protobuf:"bytes,4,opt,name=execname,proto3" json:"execname,omitempty"`
+	To                   string   `protobuf:"bytes,5,opt,name=to,proto3" json:"to,omitempty"`
+	From                 string   `protobuf:"bytes,6,opt,name=from,proto3" json:"from,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *MultiSigExecTransferFrom) Reset()         { *m = MultiSigExecTransferFrom{} }
+func (m *MultiSigExecTransferFrom) String() string { return proto.CompactTextString(m) }
+func (*MultiSigExecTransferFrom) ProtoMessage()    {}
+func (*MultiSigExecTransferFrom) Descriptor() ([]byte, []int) {
+	return fileDescriptor_62b8b91adf3febfa, []int{10}
+}
+
+func (m *MultiSigExecTransferFrom) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_MultiSigExecTransferFrom.Unmarshal(m, b)
+}
+func (m *MultiSigExecTransferFrom) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_MultiSigExecTransferFrom.Marshal(b, m, deterministic)
+}
+func (m *MultiSigExecTransferFrom) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_MultiSigExecTransferFrom.Merge(m, src)
+}
+func (m *MultiSigExecTransferFrom) XXX_Size() int {
+	return xxx_messageInfo_MultiSigExecTransferFrom.Size(m)
+}
+func (m *MultiSigExecTransferFrom) XXX_DiscardUnknown() {
+	xxx_messageInfo_MultiSigExecTransferFrom.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MultiSigExecTransferFrom proto.InternalMessageInfo
+
+func (m *MultiSigExecTransferFrom) GetSymbol() string {
+	if m != nil {
+		return m.Symbol
+	}
+	return ""
+}
+
+func (m *MultiSigExecTransferFrom) GetAmount() int64 {
+	if m != nil {
+		return m.Amount
+	}
+	return 0
+}
+
+func (m *MultiSigExecTransferFrom) GetNote() string {
+	if m != nil {
+		return m.Note
+	}
+	return ""
+}
+
+func (m *MultiSigExecTransferFrom) GetExecname() string {
+	if m != nil {
+		return m.Execname
+	}
+	return ""
+}
+
+func (m *MultiSigExecTransferFrom) GetTo() string {
+	if m != nil {
+		return m.To
+	}
+	return ""
+}
+
+func (m *MultiSigExecTransferFrom) GetFrom() string {
+	if m != nil {
+		return m.From
+	}
+	return ""
+}
+
+//多重签名合约中账户之间转币操作: addr --->MultiSigAddr之间的转账
+//需要判断to地址是否是多重签名地址
+//将MultiSig合约中签名地址上execname+symbol的资产转移到to地址
+type MultiSigExecTransferTo struct {
+	Symbol               string   `protobuf:"bytes,1,opt,name=symbol,proto3" json:"symbol,omitempty"`
+	Amount               int64    `protobuf:"varint,2,opt,name=amount,proto3" json:"amount,omitempty"`
+	Note                 string   `protobuf:"bytes,3,opt,name=note,proto3" json:"note,omitempty"`
+	Execname             string   `protobuf:"bytes,4,opt,name=execname,proto3" json:"execname,omitempty"`
+	To                   string   `protobuf:"bytes,5,opt,name=to,proto3" json:"to,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *MultiSigExecTransferTo) Reset()         { *m = MultiSigExecTransferTo{} }
+func (m *MultiSigExecTransferTo) String() string { return proto.CompactTextString(m) }
+func (*MultiSigExecTransferTo) ProtoMessage()    {}
+func (*MultiSigExecTransferTo) Descriptor() ([]byte, []int) {
+	return fileDescriptor_62b8b91adf3febfa, []int{11}
+}
+
+func (m *MultiSigExecTransferTo) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_MultiSigExecTransferTo.Unmarshal(m, b)
+}
+func (m *MultiSigExecTransferTo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_MultiSigExecTransferTo.Marshal(b, m, deterministic)
+}
+func (m *MultiSigExecTransferTo) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_MultiSigExecTransferTo.Merge(m, src)
+}
+func (m *MultiSigExecTransferTo) XXX_Size() int {
+	return xxx_messageInfo_MultiSigExecTransferTo.Size(m)
+}
+func (m *MultiSigExecTransferTo) XXX_DiscardUnknown() {
+	xxx_messageInfo_MultiSigExecTransferTo.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MultiSigExecTransferTo proto.InternalMessageInfo
+
+func (m *MultiSigExecTransferTo) GetSymbol() string {
+	if m != nil {
+		return m.Symbol
+	}
+	return ""
+}
+
+func (m *MultiSigExecTransferTo) GetAmount() int64 {
+	if m != nil {
+		return m.Amount
+	}
+	return 0
+}
+
+func (m *MultiSigExecTransferTo) GetNote() string {
+	if m != nil {
+		return m.Note
+	}
+	return ""
+}
+
+func (m *MultiSigExecTransferTo) GetExecname() string {
+	if m != nil {
+		return m.Execname
+	}
+	return ""
+}
+
+func (m *MultiSigExecTransferTo) GetTo() string {
+	if m != nil {
+		return m.To
+	}
+	return ""
+}
+
+//多重签名账户withdraw交易的确认或者取消确认
+//multisigaccaddr:多重签名账户地址
+//transactionid:多重签名账户上的withdraw交易的内部id
+type MultiSigConfirmTx struct {
+	MultiSigAccAddr      string   `protobuf:"bytes,1,opt,name=multiSigAccAddr,proto3" json:"multiSigAccAddr,omitempty"`
+	TxId                 uint64   `protobuf:"varint,2,opt,name=txId,proto3" json:"txId,omitempty"`
+	ConfirmOrRevoke      bool     `protobuf:"varint,3,opt,name=confirmOrRevoke,proto3" json:"confirmOrRevoke,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *MultiSigConfirmTx) Reset()         { *m = MultiSigConfirmTx{} }
+func (m *MultiSigConfirmTx) String() string { return proto.CompactTextString(m) }
+func (*MultiSigConfirmTx) ProtoMessage()    {}
+func (*MultiSigConfirmTx) Descriptor() ([]byte, []int) {
+	return fileDescriptor_62b8b91adf3febfa, []int{12}
+}
+
+func (m *MultiSigConfirmTx) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_MultiSigConfirmTx.Unmarshal(m, b)
+}
+func (m *MultiSigConfirmTx) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_MultiSigConfirmTx.Marshal(b, m, deterministic)
+}
+func (m *MultiSigConfirmTx) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_MultiSigConfirmTx.Merge(m, src)
+}
+func (m *MultiSigConfirmTx) XXX_Size() int {
+	return xxx_messageInfo_MultiSigConfirmTx.Size(m)
+}
+func (m *MultiSigConfirmTx) XXX_DiscardUnknown() {
+	xxx_messageInfo_MultiSigConfirmTx.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MultiSigConfirmTx proto.InternalMessageInfo
+
+func (m *MultiSigConfirmTx) GetMultiSigAccAddr() string {
+	if m != nil {
+		return m.MultiSigAccAddr
+	}
+	return ""
+}
+
+func (m *MultiSigConfirmTx) GetTxId() uint64 {
+	if m != nil {
+		return m.TxId
+	}
+	return 0
+}
+
+func (m *MultiSigConfirmTx) GetConfirmOrRevoke() bool {
+	if m != nil {
+		return m.ConfirmOrRevoke
+	}
+	return false
+}
+
+//获取所有多重签名账号
+type ReqMultiSigAccs struct {
+	Start                int64    `protobuf:"varint,1,opt,name=start,proto3" json:"start,omitempty"`
+	End                  int64    `protobuf:"varint,2,opt,name=end,proto3" json:"end,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *ReqMultiSigAccs) Reset()         { *m = ReqMultiSigAccs{} }
+func (m *ReqMultiSigAccs) String() string { return proto.CompactTextString(m) }
+func (*ReqMultiSigAccs) ProtoMessage()    {}
+func (*ReqMultiSigAccs) Descriptor() ([]byte, []int) {
+	return fileDescriptor_62b8b91adf3febfa, []int{13}
+}
+
+func (m *ReqMultiSigAccs) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_ReqMultiSigAccs.Unmarshal(m, b)
+}
+func (m *ReqMultiSigAccs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_ReqMultiSigAccs.Marshal(b, m, deterministic)
+}
+func (m *ReqMultiSigAccs) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ReqMultiSigAccs.Merge(m, src)
+}
+func (m *ReqMultiSigAccs) XXX_Size() int {
+	return xxx_messageInfo_ReqMultiSigAccs.Size(m)
+}
+func (m *ReqMultiSigAccs) XXX_DiscardUnknown() {
+	xxx_messageInfo_ReqMultiSigAccs.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ReqMultiSigAccs proto.InternalMessageInfo
+
+func (m *ReqMultiSigAccs) GetStart() int64 {
+	if m != nil {
+		return m.Start
+	}
+	return 0
+}
+
+func (m *ReqMultiSigAccs) GetEnd() int64 {
+	if m != nil {
+		return m.End
+	}
+	return 0
+}
+
+type ReplyMultiSigAccs struct {
+	Address              []string `protobuf:"bytes,1,rep,name=address,proto3" json:"address,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *ReplyMultiSigAccs) Reset()         { *m = ReplyMultiSigAccs{} }
+func (m *ReplyMultiSigAccs) String() string { return proto.CompactTextString(m) }
+func (*ReplyMultiSigAccs) ProtoMessage()    {}
+func (*ReplyMultiSigAccs) Descriptor() ([]byte, []int) {
+	return fileDescriptor_62b8b91adf3febfa, []int{14}
+}
+
+func (m *ReplyMultiSigAccs) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_ReplyMultiSigAccs.Unmarshal(m, b)
+}
+func (m *ReplyMultiSigAccs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_ReplyMultiSigAccs.Marshal(b, m, deterministic)
+}
+func (m *ReplyMultiSigAccs) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ReplyMultiSigAccs.Merge(m, src)
+}
+func (m *ReplyMultiSigAccs) XXX_Size() int {
+	return xxx_messageInfo_ReplyMultiSigAccs.Size(m)
+}
+func (m *ReplyMultiSigAccs) XXX_DiscardUnknown() {
+	xxx_messageInfo_ReplyMultiSigAccs.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ReplyMultiSigAccs proto.InternalMessageInfo
+
+func (m *ReplyMultiSigAccs) GetAddress() []string {
+	if m != nil {
+		return m.Address
+	}
+	return nil
+}
+
+//获取指定多重签名账号的状态信息
+type ReqMultiSigAccInfo struct {
+	MultiSigAccAddr      string   `protobuf:"bytes,1,opt,name=multiSigAccAddr,proto3" json:"multiSigAccAddr,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *ReqMultiSigAccInfo) Reset()         { *m = ReqMultiSigAccInfo{} }
+func (m *ReqMultiSigAccInfo) String() string { return proto.CompactTextString(m) }
+func (*ReqMultiSigAccInfo) ProtoMessage()    {}
+func (*ReqMultiSigAccInfo) Descriptor() ([]byte, []int) {
+	return fileDescriptor_62b8b91adf3febfa, []int{15}
+}
+
+func (m *ReqMultiSigAccInfo) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_ReqMultiSigAccInfo.Unmarshal(m, b)
+}
+func (m *ReqMultiSigAccInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_ReqMultiSigAccInfo.Marshal(b, m, deterministic)
+}
+func (m *ReqMultiSigAccInfo) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ReqMultiSigAccInfo.Merge(m, src)
+}
+func (m *ReqMultiSigAccInfo) XXX_Size() int {
+	return xxx_messageInfo_ReqMultiSigAccInfo.Size(m)
+}
+func (m *ReqMultiSigAccInfo) XXX_DiscardUnknown() {
+	xxx_messageInfo_ReqMultiSigAccInfo.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ReqMultiSigAccInfo proto.InternalMessageInfo
+
+func (m *ReqMultiSigAccInfo) GetMultiSigAccAddr() string {
+	if m != nil {
+		return m.MultiSigAccAddr
+	}
+	return ""
+}
+
+//指定多重签名账号的状态信息
+type ReplyMultiSigAccInfo struct {
+	CreateAddr           string        `protobuf:"bytes,1,opt,name=createAddr,proto3" json:"createAddr,omitempty"`
+	MultiSigAddr         string        `protobuf:"bytes,2,opt,name=multiSigAddr,proto3" json:"multiSigAddr,omitempty"`
+	Owners               []*Owner      `protobuf:"bytes,3,rep,name=owners,proto3" json:"owners,omitempty"`
+	DailyLimits          []*DailyLimit `protobuf:"bytes,4,rep,name=dailyLimits,proto3" json:"dailyLimits,omitempty"`
+	TxCount              uint64        `protobuf:"varint,5,opt,name=txCount,proto3" json:"txCount,omitempty"`
+	RequiredWeight       uint64        `protobuf:"varint,6,opt,name=requiredWeight,proto3" json:"requiredWeight,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
+	XXX_unrecognized     []byte        `json:"-"`
+	XXX_sizecache        int32         `json:"-"`
+}
+
+func (m *ReplyMultiSigAccInfo) Reset()         { *m = ReplyMultiSigAccInfo{} }
+func (m *ReplyMultiSigAccInfo) String() string { return proto.CompactTextString(m) }
+func (*ReplyMultiSigAccInfo) ProtoMessage()    {}
+func (*ReplyMultiSigAccInfo) Descriptor() ([]byte, []int) {
+	return fileDescriptor_62b8b91adf3febfa, []int{16}
+}
+
+func (m *ReplyMultiSigAccInfo) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_ReplyMultiSigAccInfo.Unmarshal(m, b)
+}
+func (m *ReplyMultiSigAccInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_ReplyMultiSigAccInfo.Marshal(b, m, deterministic)
+}
+func (m *ReplyMultiSigAccInfo) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ReplyMultiSigAccInfo.Merge(m, src)
+}
+func (m *ReplyMultiSigAccInfo) XXX_Size() int {
+	return xxx_messageInfo_ReplyMultiSigAccInfo.Size(m)
+}
+func (m *ReplyMultiSigAccInfo) XXX_DiscardUnknown() {
+	xxx_messageInfo_ReplyMultiSigAccInfo.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ReplyMultiSigAccInfo proto.InternalMessageInfo
+
+func (m *ReplyMultiSigAccInfo) GetCreateAddr() string {
+	if m != nil {
+		return m.CreateAddr
+	}
+	return ""
+}
+
+func (m *ReplyMultiSigAccInfo) GetMultiSigAddr() string {
+	if m != nil {
+		return m.MultiSigAddr
+	}
+	return ""
+}
+
+func (m *ReplyMultiSigAccInfo) GetOwners() []*Owner {
+	if m != nil {
+		return m.Owners
+	}
+	return nil
+}
+
+func (m *ReplyMultiSigAccInfo) GetDailyLimits() []*DailyLimit {
+	if m != nil {
+		return m.DailyLimits
+	}
+	return nil
+}
+
+func (m *ReplyMultiSigAccInfo) GetTxCount() uint64 {
+	if m != nil {
+		return m.TxCount
+	}
+	return 0
+}
+
+func (m *ReplyMultiSigAccInfo) GetRequiredWeight() uint64 {
+	if m != nil {
+		return m.RequiredWeight
+	}
+	return 0
+}
+
+//获取txids设置过滤条件和区间，pending, executed
+type ReqMultiSigTxids struct {
+	MultiSigAddr         string   `protobuf:"bytes,1,opt,name=multiSigAddr,proto3" json:"multiSigAddr,omitempty"`
+	FromTxId             uint64   `protobuf:"varint,2,opt,name=fromTxId,proto3" json:"fromTxId,omitempty"`
+	ToTxId               uint64   `protobuf:"varint,3,opt,name=toTxId,proto3" json:"toTxId,omitempty"`
+	Pending              bool     `protobuf:"varint,4,opt,name=pending,proto3" json:"pending,omitempty"`
+	Executed             bool     `protobuf:"varint,5,opt,name=executed,proto3" json:"executed,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *ReqMultiSigTxids) Reset()         { *m = ReqMultiSigTxids{} }
+func (m *ReqMultiSigTxids) String() string { return proto.CompactTextString(m) }
+func (*ReqMultiSigTxids) ProtoMessage()    {}
+func (*ReqMultiSigTxids) Descriptor() ([]byte, []int) {
+	return fileDescriptor_62b8b91adf3febfa, []int{17}
+}
+
+func (m *ReqMultiSigTxids) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_ReqMultiSigTxids.Unmarshal(m, b)
+}
+func (m *ReqMultiSigTxids) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_ReqMultiSigTxids.Marshal(b, m, deterministic)
+}
+func (m *ReqMultiSigTxids) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ReqMultiSigTxids.Merge(m, src)
+}
+func (m *ReqMultiSigTxids) XXX_Size() int {
+	return xxx_messageInfo_ReqMultiSigTxids.Size(m)
+}
+func (m *ReqMultiSigTxids) XXX_DiscardUnknown() {
+	xxx_messageInfo_ReqMultiSigTxids.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ReqMultiSigTxids proto.InternalMessageInfo
+
+func (m *ReqMultiSigTxids) GetMultiSigAddr() string {
+	if m != nil {
+		return m.MultiSigAddr
+	}
+	return ""
+}
+
+func (m *ReqMultiSigTxids) GetFromTxId() uint64 {
+	if m != nil {
+		return m.FromTxId
+	}
+	return 0
+}
+
+func (m *ReqMultiSigTxids) GetToTxId() uint64 {
+	if m != nil {
+		return m.ToTxId
+	}
+	return 0
+}
+
+func (m *ReqMultiSigTxids) GetPending() bool {
+	if m != nil {
+		return m.Pending
+	}
+	return false
+}
+
+func (m *ReqMultiSigTxids) GetExecuted() bool {
+	if m != nil {
+		return m.Executed
+	}
+	return false
+}
+
+type ReplyMultiSigTxids struct {
+	MultiSigAddr         string   `protobuf:"bytes,1,opt,name=multiSigAddr,proto3" json:"multiSigAddr,omitempty"`
+	Txids                []uint64 `protobuf:"varint,2,rep,packed,name=txids,proto3" json:"txids,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *ReplyMultiSigTxids) Reset()         { *m = ReplyMultiSigTxids{} }
+func (m *ReplyMultiSigTxids) String() string { return proto.CompactTextString(m) }
+func (*ReplyMultiSigTxids) ProtoMessage()    {}
+func (*ReplyMultiSigTxids) Descriptor() ([]byte, []int) {
+	return fileDescriptor_62b8b91adf3febfa, []int{18}
+}
+
+func (m *ReplyMultiSigTxids) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_ReplyMultiSigTxids.Unmarshal(m, b)
+}
+func (m *ReplyMultiSigTxids) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_ReplyMultiSigTxids.Marshal(b, m, deterministic)
+}
+func (m *ReplyMultiSigTxids) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ReplyMultiSigTxids.Merge(m, src)
+}
+func (m *ReplyMultiSigTxids) XXX_Size() int {
+	return xxx_messageInfo_ReplyMultiSigTxids.Size(m)
+}
+func (m *ReplyMultiSigTxids) XXX_DiscardUnknown() {
+	xxx_messageInfo_ReplyMultiSigTxids.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ReplyMultiSigTxids proto.InternalMessageInfo
+
+func (m *ReplyMultiSigTxids) GetMultiSigAddr() string {
+	if m != nil {
+		return m.MultiSigAddr
+	}
+	return ""
+}
+
+func (m *ReplyMultiSigTxids) GetTxids() []uint64 {
+	if m != nil {
+		return m.Txids
+	}
+	return nil
+}
+
+//获取txid交易的信息，以及参与确认的owner信息
+type ReqMultiSigTxInfo struct {
+	MultiSigAddr         string   `protobuf:"bytes,1,opt,name=multiSigAddr,proto3" json:"multiSigAddr,omitempty"`
+	TxId                 uint64   `protobuf:"varint,2,opt,name=txId,proto3" json:"txId,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *ReqMultiSigTxInfo) Reset()         { *m = ReqMultiSigTxInfo{} }
+func (m *ReqMultiSigTxInfo) String() string { return proto.CompactTextString(m) }
+func (*ReqMultiSigTxInfo) ProtoMessage()    {}
+func (*ReqMultiSigTxInfo) Descriptor() ([]byte, []int) {
+	return fileDescriptor_62b8b91adf3febfa, []int{19}
+}
+
+func (m *ReqMultiSigTxInfo) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_ReqMultiSigTxInfo.Unmarshal(m, b)
+}
+func (m *ReqMultiSigTxInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_ReqMultiSigTxInfo.Marshal(b, m, deterministic)
+}
+func (m *ReqMultiSigTxInfo) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ReqMultiSigTxInfo.Merge(m, src)
+}
+func (m *ReqMultiSigTxInfo) XXX_Size() int {
+	return xxx_messageInfo_ReqMultiSigTxInfo.Size(m)
+}
+func (m *ReqMultiSigTxInfo) XXX_DiscardUnknown() {
+	xxx_messageInfo_ReqMultiSigTxInfo.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ReqMultiSigTxInfo proto.InternalMessageInfo
+
+func (m *ReqMultiSigTxInfo) GetMultiSigAddr() string {
+	if m != nil {
+		return m.MultiSigAddr
+	}
+	return ""
+}
+
+func (m *ReqMultiSigTxInfo) GetTxId() uint64 {
+	if m != nil {
+		return m.TxId
+	}
+	return 0
+}
+
+type ReplyMultiSigTxInfo struct {
+	MultiSigTxInfo       *MultiSigTx `protobuf:"bytes,1,opt,name=multiSigTxInfo,proto3" json:"multiSigTxInfo,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
+	XXX_unrecognized     []byte      `json:"-"`
+	XXX_sizecache        int32       `json:"-"`
+}
+
+func (m *ReplyMultiSigTxInfo) Reset()         { *m = ReplyMultiSigTxInfo{} }
+func (m *ReplyMultiSigTxInfo) String() string { return proto.CompactTextString(m) }
+func (*ReplyMultiSigTxInfo) ProtoMessage()    {}
+func (*ReplyMultiSigTxInfo) Descriptor() ([]byte, []int) {
+	return fileDescriptor_62b8b91adf3febfa, []int{20}
+}
+
+func (m *ReplyMultiSigTxInfo) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_ReplyMultiSigTxInfo.Unmarshal(m, b)
+}
+func (m *ReplyMultiSigTxInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_ReplyMultiSigTxInfo.Marshal(b, m, deterministic)
+}
+func (m *ReplyMultiSigTxInfo) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ReplyMultiSigTxInfo.Merge(m, src)
+}
+func (m *ReplyMultiSigTxInfo) XXX_Size() int {
+	return xxx_messageInfo_ReplyMultiSigTxInfo.Size(m)
+}
+func (m *ReplyMultiSigTxInfo) XXX_DiscardUnknown() {
+	xxx_messageInfo_ReplyMultiSigTxInfo.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ReplyMultiSigTxInfo proto.InternalMessageInfo
+
+func (m *ReplyMultiSigTxInfo) GetMultiSigTxInfo() *MultiSigTx {
+	if m != nil {
+		return m.MultiSigTxInfo
+	}
+	return nil
+}
+
+//获取指定资产当日剩余的免多重签名的余额
+type ReqMultiSigAccUnSpentToday struct {
+	MultiSigAddr         string   `protobuf:"bytes,1,opt,name=multiSigAddr,proto3" json:"multiSigAddr,omitempty"`
+	Execer               string   `protobuf:"bytes,2,opt,name=execer,proto3" json:"execer,omitempty"`
+	Symbol               string   `protobuf:"bytes,3,opt,name=symbol,proto3" json:"symbol,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *ReqMultiSigAccUnSpentToday) Reset()         { *m = ReqMultiSigAccUnSpentToday{} }
+func (m *ReqMultiSigAccUnSpentToday) String() string { return proto.CompactTextString(m) }
+func (*ReqMultiSigAccUnSpentToday) ProtoMessage()    {}
+func (*ReqMultiSigAccUnSpentToday) Descriptor() ([]byte, []int) {
+	return fileDescriptor_62b8b91adf3febfa, []int{21}
+}
+
+func (m *ReqMultiSigAccUnSpentToday) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_ReqMultiSigAccUnSpentToday.Unmarshal(m, b)
+}
+func (m *ReqMultiSigAccUnSpentToday) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_ReqMultiSigAccUnSpentToday.Marshal(b, m, deterministic)
+}
+func (m *ReqMultiSigAccUnSpentToday) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ReqMultiSigAccUnSpentToday.Merge(m, src)
+}
+func (m *ReqMultiSigAccUnSpentToday) XXX_Size() int {
+	return xxx_messageInfo_ReqMultiSigAccUnSpentToday.Size(m)
+}
+func (m *ReqMultiSigAccUnSpentToday) XXX_DiscardUnknown() {
+	xxx_messageInfo_ReqMultiSigAccUnSpentToday.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ReqMultiSigAccUnSpentToday proto.InternalMessageInfo
+
+func (m *ReqMultiSigAccUnSpentToday) GetMultiSigAddr() string {
+	if m != nil {
+		return m.MultiSigAddr
+	}
+	return ""
+}
+
+func (m *ReqMultiSigAccUnSpentToday) GetExecer() string {
+	if m != nil {
+		return m.Execer
+	}
+	return ""
+}
+
+func (m *ReqMultiSigAccUnSpentToday) GetSymbol() string {
+	if m != nil {
+		return m.Symbol
+	}
+	return ""
+}
+
+type ReplyUnSpentAssets struct {
+	UnSpentAssets        []*UnSpentAssets `protobuf:"bytes,3,rep,name=unSpentAssets,proto3" json:"unSpentAssets,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
+	XXX_unrecognized     []byte           `json:"-"`
+	XXX_sizecache        int32            `json:"-"`
+}
+
+func (m *ReplyUnSpentAssets) Reset()         { *m = ReplyUnSpentAssets{} }
+func (m *ReplyUnSpentAssets) String() string { return proto.CompactTextString(m) }
+func (*ReplyUnSpentAssets) ProtoMessage()    {}
+func (*ReplyUnSpentAssets) Descriptor() ([]byte, []int) {
+	return fileDescriptor_62b8b91adf3febfa, []int{22}
+}
+
+func (m *ReplyUnSpentAssets) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_ReplyUnSpentAssets.Unmarshal(m, b)
+}
+func (m *ReplyUnSpentAssets) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_ReplyUnSpentAssets.Marshal(b, m, deterministic)
+}
+func (m *ReplyUnSpentAssets) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ReplyUnSpentAssets.Merge(m, src)
+}
+func (m *ReplyUnSpentAssets) XXX_Size() int {
+	return xxx_messageInfo_ReplyUnSpentAssets.Size(m)
+}
+func (m *ReplyUnSpentAssets) XXX_DiscardUnknown() {
+	xxx_messageInfo_ReplyUnSpentAssets.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ReplyUnSpentAssets proto.InternalMessageInfo
+
+func (m *ReplyUnSpentAssets) GetUnSpentAssets() []*UnSpentAssets {
+	if m != nil {
+		return m.UnSpentAssets
+	}
+	return nil
+}
+
+type UnSpentAssets struct {
+	Assets               *Assets  `protobuf:"bytes,1,opt,name=assets,proto3" json:"assets,omitempty"`
+	Amount               uint64   `protobuf:"varint,2,opt,name=amount,proto3" json:"amount,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *UnSpentAssets) Reset()         { *m = UnSpentAssets{} }
+func (m *UnSpentAssets) String() string { return proto.CompactTextString(m) }
+func (*UnSpentAssets) ProtoMessage()    {}
+func (*UnSpentAssets) Descriptor() ([]byte, []int) {
+	return fileDescriptor_62b8b91adf3febfa, []int{23}
+}
+
+func (m *UnSpentAssets) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_UnSpentAssets.Unmarshal(m, b)
+}
+func (m *UnSpentAssets) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_UnSpentAssets.Marshal(b, m, deterministic)
+}
+func (m *UnSpentAssets) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_UnSpentAssets.Merge(m, src)
+}
+func (m *UnSpentAssets) XXX_Size() int {
+	return xxx_messageInfo_UnSpentAssets.Size(m)
+}
+func (m *UnSpentAssets) XXX_DiscardUnknown() {
+	xxx_messageInfo_UnSpentAssets.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_UnSpentAssets proto.InternalMessageInfo
+
+func (m *UnSpentAssets) GetAssets() *Assets {
+	if m != nil {
+		return m.Assets
+	}
+	return nil
+}
+
+func (m *UnSpentAssets) GetAmount() uint64 {
+	if m != nil {
+		return m.Amount
+	}
+	return 0
+}
+
+//TyLogMultiSigAccCreate交易的执行Receipt
+type ReceiptMultiSig struct {
+	MultiSigAddr         string   `protobuf:"bytes,1,opt,name=multiSigAddr,proto3" json:"multiSigAddr,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *ReceiptMultiSig) Reset()         { *m = ReceiptMultiSig{} }
+func (m *ReceiptMultiSig) String() string { return proto.CompactTextString(m) }
+func (*ReceiptMultiSig) ProtoMessage()    {}
+func (*ReceiptMultiSig) Descriptor() ([]byte, []int) {
+	return fileDescriptor_62b8b91adf3febfa, []int{24}
+}
+
+func (m *ReceiptMultiSig) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_ReceiptMultiSig.Unmarshal(m, b)
+}
+func (m *ReceiptMultiSig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_ReceiptMultiSig.Marshal(b, m, deterministic)
+}
+func (m *ReceiptMultiSig) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ReceiptMultiSig.Merge(m, src)
+}
+func (m *ReceiptMultiSig) XXX_Size() int {
+	return xxx_messageInfo_ReceiptMultiSig.Size(m)
+}
+func (m *ReceiptMultiSig) XXX_DiscardUnknown() {
+	xxx_messageInfo_ReceiptMultiSig.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ReceiptMultiSig proto.InternalMessageInfo
+
+func (m *ReceiptMultiSig) GetMultiSigAddr() string {
+	if m != nil {
+		return m.MultiSigAddr
+	}
+	return ""
+}
+
+type ReceiptOwnerAddOrDel struct {
+	MultiSigAddr         string   `protobuf:"bytes,1,opt,name=multiSigAddr,proto3" json:"multiSigAddr,omitempty"`
+	Owner                *Owner   `protobuf:"bytes,2,opt,name=owner,proto3" json:"owner,omitempty"`
+	AddOrDel             bool     `protobuf:"varint,3,opt,name=addOrDel,proto3" json:"addOrDel,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *ReceiptOwnerAddOrDel) Reset()         { *m = ReceiptOwnerAddOrDel{} }
+func (m *ReceiptOwnerAddOrDel) String() string { return proto.CompactTextString(m) }
+func (*ReceiptOwnerAddOrDel) ProtoMessage()    {}
+func (*ReceiptOwnerAddOrDel) Descriptor() ([]byte, []int) {
+	return fileDescriptor_62b8b91adf3febfa, []int{25}
+}
+
+func (m *ReceiptOwnerAddOrDel) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_ReceiptOwnerAddOrDel.Unmarshal(m, b)
+}
+func (m *ReceiptOwnerAddOrDel) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_ReceiptOwnerAddOrDel.Marshal(b, m, deterministic)
+}
+func (m *ReceiptOwnerAddOrDel) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ReceiptOwnerAddOrDel.Merge(m, src)
+}
+func (m *ReceiptOwnerAddOrDel) XXX_Size() int {
+	return xxx_messageInfo_ReceiptOwnerAddOrDel.Size(m)
+}
+func (m *ReceiptOwnerAddOrDel) XXX_DiscardUnknown() {
+	xxx_messageInfo_ReceiptOwnerAddOrDel.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ReceiptOwnerAddOrDel proto.InternalMessageInfo
+
+func (m *ReceiptOwnerAddOrDel) GetMultiSigAddr() string {
+	if m != nil {
+		return m.MultiSigAddr
+	}
+	return ""
+}
+
+func (m *ReceiptOwnerAddOrDel) GetOwner() *Owner {
+	if m != nil {
+		return m.Owner
+	}
+	return nil
+}
+
+func (m *ReceiptOwnerAddOrDel) GetAddOrDel() bool {
+	if m != nil {
+		return m.AddOrDel
+	}
+	return false
+}
+
+//TyLogMultiSigOwnerModify  = 10003 //输出modify的owner：preweight以及currentweight
+//TyLogMultiSigOwnerReplace = 10004 //输出old的owner的信息：以及当前的owner信息：addr+weight
+type ReceiptOwnerModOrRep struct {
+	MultiSigAddr         string   `protobuf:"bytes,1,opt,name=multiSigAddr,proto3" json:"multiSigAddr,omitempty"`
+	PrevOwner            *Owner   `protobuf:"bytes,2,opt,name=prevOwner,proto3" json:"prevOwner,omitempty"`
+	CurrentOwner         *Owner   `protobuf:"bytes,3,opt,name=currentOwner,proto3" json:"currentOwner,omitempty"`
+	ModOrRep             bool     `protobuf:"varint,4,opt,name=modOrRep,proto3" json:"modOrRep,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *ReceiptOwnerModOrRep) Reset()         { *m = ReceiptOwnerModOrRep{} }
+func (m *ReceiptOwnerModOrRep) String() string { return proto.CompactTextString(m) }
+func (*ReceiptOwnerModOrRep) ProtoMessage()    {}
+func (*ReceiptOwnerModOrRep) Descriptor() ([]byte, []int) {
+	return fileDescriptor_62b8b91adf3febfa, []int{26}
+}
+
+func (m *ReceiptOwnerModOrRep) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_ReceiptOwnerModOrRep.Unmarshal(m, b)
+}
+func (m *ReceiptOwnerModOrRep) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_ReceiptOwnerModOrRep.Marshal(b, m, deterministic)
+}
+func (m *ReceiptOwnerModOrRep) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ReceiptOwnerModOrRep.Merge(m, src)
+}
+func (m *ReceiptOwnerModOrRep) XXX_Size() int {
+	return xxx_messageInfo_ReceiptOwnerModOrRep.Size(m)
+}
+func (m *ReceiptOwnerModOrRep) XXX_DiscardUnknown() {
+	xxx_messageInfo_ReceiptOwnerModOrRep.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ReceiptOwnerModOrRep proto.InternalMessageInfo
+
+func (m *ReceiptOwnerModOrRep) GetMultiSigAddr() string {
+	if m != nil {
+		return m.MultiSigAddr
+	}
+	return ""
+}
+
+func (m *ReceiptOwnerModOrRep) GetPrevOwner() *Owner {
+	if m != nil {
+		return m.PrevOwner
+	}
+	return nil
+}
+
+func (m *ReceiptOwnerModOrRep) GetCurrentOwner() *Owner {
+	if m != nil {
+		return m.CurrentOwner
+	}
+	return nil
+}
+
+func (m *ReceiptOwnerModOrRep) GetModOrRep() bool {
+	if m != nil {
+		return m.ModOrRep
+	}
+	return false
+}
+
+//多重签名账户的操作：ReqWeight，AssetDailyLimit
+//TyLogMultiSigAccWeightModify     = 10005 //输出修改前后确认权重的值：preReqWeight和curReqWeight
+type ReceiptWeightModify struct {
+	MultiSigAddr         string   `protobuf:"bytes,1,opt,name=multiSigAddr,proto3" json:"multiSigAddr,omitempty"`
+	PrevWeight           uint64   `protobuf:"varint,2,opt,name=prevWeight,proto3" json:"prevWeight,omitempty"`
+	CurrentWeight        uint64   `protobuf:"varint,3,opt,name=currentWeight,proto3" json:"currentWeight,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *ReceiptWeightModify) Reset()         { *m = ReceiptWeightModify{} }
+func (m *ReceiptWeightModify) String() string { return proto.CompactTextString(m) }
+func (*ReceiptWeightModify) ProtoMessage()    {}
+func (*ReceiptWeightModify) Descriptor() ([]byte, []int) {
+	return fileDescriptor_62b8b91adf3febfa, []int{27}
+}
+
+func (m *ReceiptWeightModify) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_ReceiptWeightModify.Unmarshal(m, b)
+}
+func (m *ReceiptWeightModify) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_ReceiptWeightModify.Marshal(b, m, deterministic)
+}
+func (m *ReceiptWeightModify) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ReceiptWeightModify.Merge(m, src)
+}
+func (m *ReceiptWeightModify) XXX_Size() int {
+	return xxx_messageInfo_ReceiptWeightModify.Size(m)
+}
+func (m *ReceiptWeightModify) XXX_DiscardUnknown() {
+	xxx_messageInfo_ReceiptWeightModify.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ReceiptWeightModify proto.InternalMessageInfo
+
+func (m *ReceiptWeightModify) GetMultiSigAddr() string {
+	if m != nil {
+		return m.MultiSigAddr
+	}
+	return ""
+}
+
+func (m *ReceiptWeightModify) GetPrevWeight() uint64 {
+	if m != nil {
+		return m.PrevWeight
+	}
+	return 0
+}
+
+func (m *ReceiptWeightModify) GetCurrentWeight() uint64 {
+	if m != nil {
+		return m.CurrentWeight
+	}
+	return 0
+}
+
+//TyLogMultiSigAccDailyLimitAdd    = 10006 //输出add的DailyLimit：Symbol和DailyLimit
+//TyLogMultiSigAccDailyLimitModify = 10007 //输出modify的DailyLimit：preDailyLimit以及currentDailyLimit
+type ReceiptDailyLimitOperate struct {
+	MultiSigAddr         string      `protobuf:"bytes,1,opt,name=multiSigAddr,proto3" json:"multiSigAddr,omitempty"`
+	PrevDailyLimit       *DailyLimit `protobuf:"bytes,2,opt,name=prevDailyLimit,proto3" json:"prevDailyLimit,omitempty"`
+	CurDailyLimit        *DailyLimit `protobuf:"bytes,3,opt,name=curDailyLimit,proto3" json:"curDailyLimit,omitempty"`
+	AddOrModify          bool        `protobuf:"varint,4,opt,name=addOrModify,proto3" json:"addOrModify,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
+	XXX_unrecognized     []byte      `json:"-"`
+	XXX_sizecache        int32       `json:"-"`
+}
+
+func (m *ReceiptDailyLimitOperate) Reset()         { *m = ReceiptDailyLimitOperate{} }
+func (m *ReceiptDailyLimitOperate) String() string { return proto.CompactTextString(m) }
+func (*ReceiptDailyLimitOperate) ProtoMessage()    {}
+func (*ReceiptDailyLimitOperate) Descriptor() ([]byte, []int) {
+	return fileDescriptor_62b8b91adf3febfa, []int{28}
+}
+
+func (m *ReceiptDailyLimitOperate) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_ReceiptDailyLimitOperate.Unmarshal(m, b)
+}
+func (m *ReceiptDailyLimitOperate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_ReceiptDailyLimitOperate.Marshal(b, m, deterministic)
+}
+func (m *ReceiptDailyLimitOperate) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ReceiptDailyLimitOperate.Merge(m, src)
+}
+func (m *ReceiptDailyLimitOperate) XXX_Size() int {
+	return xxx_messageInfo_ReceiptDailyLimitOperate.Size(m)
+}
+func (m *ReceiptDailyLimitOperate) XXX_DiscardUnknown() {
+	xxx_messageInfo_ReceiptDailyLimitOperate.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ReceiptDailyLimitOperate proto.InternalMessageInfo
+
+func (m *ReceiptDailyLimitOperate) GetMultiSigAddr() string {
+	if m != nil {
+		return m.MultiSigAddr
+	}
+	return ""
+}
+
+func (m *ReceiptDailyLimitOperate) GetPrevDailyLimit() *DailyLimit {
+	if m != nil {
+		return m.PrevDailyLimit
+	}
+	return nil
+}
+
+func (m *ReceiptDailyLimitOperate) GetCurDailyLimit() *DailyLimit {
+	if m != nil {
+		return m.CurDailyLimit
+	}
+	return nil
+}
+
+func (m *ReceiptDailyLimitOperate) GetAddOrModify() bool {
+	if m != nil {
+		return m.AddOrModify
+	}
+	return false
+}
+
+//交易确认或者撤销（撤销值针对未执行的交易）
+//TyLogMultiSigConfirmTx       = 10008 //输出确认的交易id，以及owner信息：addr+weight
+//TyLogMultiSigConfirmTxRevoke = 10009 //输出撤销确认的交易id，以及owner信息：addr+weight
+type ReceiptConfirmTx struct {
+	MultiSigTxOwner      *MultiSigTxOwner `protobuf:"bytes,1,opt,name=multiSigTxOwner,proto3" json:"multiSigTxOwner,omitempty"`
+	ConfirmeOrRevoke     bool             `protobuf:"varint,2,opt,name=confirmeOrRevoke,proto3" json:"confirmeOrRevoke,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
+	XXX_unrecognized     []byte           `json:"-"`
+	XXX_sizecache        int32            `json:"-"`
+}
+
+func (m *ReceiptConfirmTx) Reset()         { *m = ReceiptConfirmTx{} }
+func (m *ReceiptConfirmTx) String() string { return proto.CompactTextString(m) }
+func (*ReceiptConfirmTx) ProtoMessage()    {}
+func (*ReceiptConfirmTx) Descriptor() ([]byte, []int) {
+	return fileDescriptor_62b8b91adf3febfa, []int{29}
+}
+
+func (m *ReceiptConfirmTx) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_ReceiptConfirmTx.Unmarshal(m, b)
+}
+func (m *ReceiptConfirmTx) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_ReceiptConfirmTx.Marshal(b, m, deterministic)
+}
+func (m *ReceiptConfirmTx) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ReceiptConfirmTx.Merge(m, src)
+}
+func (m *ReceiptConfirmTx) XXX_Size() int {
+	return xxx_messageInfo_ReceiptConfirmTx.Size(m)
+}
+func (m *ReceiptConfirmTx) XXX_DiscardUnknown() {
+	xxx_messageInfo_ReceiptConfirmTx.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ReceiptConfirmTx proto.InternalMessageInfo
+
+func (m *ReceiptConfirmTx) GetMultiSigTxOwner() *MultiSigTxOwner {
+	if m != nil {
+		return m.MultiSigTxOwner
+	}
+	return nil
+}
+
+func (m *ReceiptConfirmTx) GetConfirmeOrRevoke() bool {
+	if m != nil {
+		return m.ConfirmeOrRevoke
+	}
+	return false
+}
+
+//可能会修改dailyLimit的相关属性
+type ReceiptAccDailyLimitUpdate struct {
+	MultiSigAddr         string      `protobuf:"bytes,1,opt,name=multiSigAddr,proto3" json:"multiSigAddr,omitempty"`
+	PrevDailyLimit       *DailyLimit `protobuf:"bytes,2,opt,name=prevDailyLimit,proto3" json:"prevDailyLimit,omitempty"`
+	CurDailyLimit        *DailyLimit `protobuf:"bytes,3,opt,name=curDailyLimit,proto3" json:"curDailyLimit,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
+	XXX_unrecognized     []byte      `json:"-"`
+	XXX_sizecache        int32       `json:"-"`
+}
+
+func (m *ReceiptAccDailyLimitUpdate) Reset()         { *m = ReceiptAccDailyLimitUpdate{} }
+func (m *ReceiptAccDailyLimitUpdate) String() string { return proto.CompactTextString(m) }
+func (*ReceiptAccDailyLimitUpdate) ProtoMessage()    {}
+func (*ReceiptAccDailyLimitUpdate) Descriptor() ([]byte, []int) {
+	return fileDescriptor_62b8b91adf3febfa, []int{30}
+}
+
+func (m *ReceiptAccDailyLimitUpdate) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_ReceiptAccDailyLimitUpdate.Unmarshal(m, b)
+}
+func (m *ReceiptAccDailyLimitUpdate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_ReceiptAccDailyLimitUpdate.Marshal(b, m, deterministic)
+}
+func (m *ReceiptAccDailyLimitUpdate) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ReceiptAccDailyLimitUpdate.Merge(m, src)
+}
+func (m *ReceiptAccDailyLimitUpdate) XXX_Size() int {
+	return xxx_messageInfo_ReceiptAccDailyLimitUpdate.Size(m)
+}
+func (m *ReceiptAccDailyLimitUpdate) XXX_DiscardUnknown() {
+	xxx_messageInfo_ReceiptAccDailyLimitUpdate.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ReceiptAccDailyLimitUpdate proto.InternalMessageInfo
+
+func (m *ReceiptAccDailyLimitUpdate) GetMultiSigAddr() string {
+	if m != nil {
+		return m.MultiSigAddr
+	}
+	return ""
+}
+
+func (m *ReceiptAccDailyLimitUpdate) GetPrevDailyLimit() *DailyLimit {
+	if m != nil {
+		return m.PrevDailyLimit
+	}
+	return nil
+}
+
+func (m *ReceiptAccDailyLimitUpdate) GetCurDailyLimit() *DailyLimit {
+	if m != nil {
+		return m.CurDailyLimit
+	}
+	return nil
+}
+
+//执行MultiSigAcc相关的交易可能会修改tx的执行状态和增加确认owner
+type ReceiptMultiSigTx struct {
+	MultiSigTxOwner      *MultiSigTxOwner `protobuf:"bytes,1,opt,name=multiSigTxOwner,proto3" json:"multiSigTxOwner,omitempty"`
+	PrevExecuted         bool             `protobuf:"varint,2,opt,name=prevExecuted,proto3" json:"prevExecuted,omitempty"`
+	CurExecuted          bool             `protobuf:"varint,3,opt,name=curExecuted,proto3" json:"curExecuted,omitempty"`
+	SubmitOrConfirm      bool             `protobuf:"varint,4,opt,name=submitOrConfirm,proto3" json:"submitOrConfirm,omitempty"`
+	TxHash               string           `protobuf:"bytes,5,opt,name=txHash,proto3" json:"txHash,omitempty"`
+	TxType               uint64           `protobuf:"varint,6,opt,name=txType,proto3" json:"txType,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
+	XXX_unrecognized     []byte           `json:"-"`
+	XXX_sizecache        int32            `json:"-"`
+}
+
+func (m *ReceiptMultiSigTx) Reset()         { *m = ReceiptMultiSigTx{} }
+func (m *ReceiptMultiSigTx) String() string { return proto.CompactTextString(m) }
+func (*ReceiptMultiSigTx) ProtoMessage()    {}
+func (*ReceiptMultiSigTx) Descriptor() ([]byte, []int) {
+	return fileDescriptor_62b8b91adf3febfa, []int{31}
+}
+
+func (m *ReceiptMultiSigTx) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_ReceiptMultiSigTx.Unmarshal(m, b)
+}
+func (m *ReceiptMultiSigTx) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_ReceiptMultiSigTx.Marshal(b, m, deterministic)
+}
+func (m *ReceiptMultiSigTx) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ReceiptMultiSigTx.Merge(m, src)
+}
+func (m *ReceiptMultiSigTx) XXX_Size() int {
+	return xxx_messageInfo_ReceiptMultiSigTx.Size(m)
+}
+func (m *ReceiptMultiSigTx) XXX_DiscardUnknown() {
+	xxx_messageInfo_ReceiptMultiSigTx.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ReceiptMultiSigTx proto.InternalMessageInfo
+
+func (m *ReceiptMultiSigTx) GetMultiSigTxOwner() *MultiSigTxOwner {
+	if m != nil {
+		return m.MultiSigTxOwner
+	}
+	return nil
+}
+
+func (m *ReceiptMultiSigTx) GetPrevExecuted() bool {
+	if m != nil {
+		return m.PrevExecuted
+	}
+	return false
+}
+
+func (m *ReceiptMultiSigTx) GetCurExecuted() bool {
+	if m != nil {
+		return m.CurExecuted
+	}
+	return false
+}
+
+func (m *ReceiptMultiSigTx) GetSubmitOrConfirm() bool {
+	if m != nil {
+		return m.SubmitOrConfirm
+	}
+	return false
+}
+
+func (m *ReceiptMultiSigTx) GetTxHash() string {
+	if m != nil {
+		return m.TxHash
+	}
+	return ""
+}
+
+func (m *ReceiptMultiSigTx) GetTxType() uint64 {
+	if m != nil {
+		return m.TxType
+	}
+	return 0
+}
+
+type ReceiptTxCountUpdate struct {
+	MultiSigAddr         string   `protobuf:"bytes,1,opt,name=multiSigAddr,proto3" json:"multiSigAddr,omitempty"`
+	CurTxCount           uint64   `protobuf:"varint,2,opt,name=curTxCount,proto3" json:"curTxCount,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *ReceiptTxCountUpdate) Reset()         { *m = ReceiptTxCountUpdate{} }
+func (m *ReceiptTxCountUpdate) String() string { return proto.CompactTextString(m) }
+func (*ReceiptTxCountUpdate) ProtoMessage()    {}
+func (*ReceiptTxCountUpdate) Descriptor() ([]byte, []int) {
+	return fileDescriptor_62b8b91adf3febfa, []int{32}
+}
+
+func (m *ReceiptTxCountUpdate) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_ReceiptTxCountUpdate.Unmarshal(m, b)
+}
+func (m *ReceiptTxCountUpdate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_ReceiptTxCountUpdate.Marshal(b, m, deterministic)
+}
+func (m *ReceiptTxCountUpdate) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ReceiptTxCountUpdate.Merge(m, src)
+}
+func (m *ReceiptTxCountUpdate) XXX_Size() int {
+	return xxx_messageInfo_ReceiptTxCountUpdate.Size(m)
+}
+func (m *ReceiptTxCountUpdate) XXX_DiscardUnknown() {
+	xxx_messageInfo_ReceiptTxCountUpdate.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ReceiptTxCountUpdate proto.InternalMessageInfo
+
+func (m *ReceiptTxCountUpdate) GetMultiSigAddr() string {
+	if m != nil {
+		return m.MultiSigAddr
+	}
+	return ""
+}
+
+func (m *ReceiptTxCountUpdate) GetCurTxCount() uint64 {
+	if m != nil {
+		return m.CurTxCount
+	}
+	return 0
+}
+
+type MultiSigTxOwner struct {
+	MultiSigAddr         string   `protobuf:"bytes,1,opt,name=multiSigAddr,proto3" json:"multiSigAddr,omitempty"`
+	Txid                 uint64   `protobuf:"varint,2,opt,name=txid,proto3" json:"txid,omitempty"`
+	ConfirmedOwner       *Owner   `protobuf:"bytes,3,opt,name=confirmedOwner,proto3" json:"confirmedOwner,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *MultiSigTxOwner) Reset()         { *m = MultiSigTxOwner{} }
+func (m *MultiSigTxOwner) String() string { return proto.CompactTextString(m) }
+func (*MultiSigTxOwner) ProtoMessage()    {}
+func (*MultiSigTxOwner) Descriptor() ([]byte, []int) {
+	return fileDescriptor_62b8b91adf3febfa, []int{33}
+}
+
+func (m *MultiSigTxOwner) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_MultiSigTxOwner.Unmarshal(m, b)
+}
+func (m *MultiSigTxOwner) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_MultiSigTxOwner.Marshal(b, m, deterministic)
+}
+func (m *MultiSigTxOwner) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_MultiSigTxOwner.Merge(m, src)
+}
+func (m *MultiSigTxOwner) XXX_Size() int {
+	return xxx_messageInfo_MultiSigTxOwner.Size(m)
+}
+func (m *MultiSigTxOwner) XXX_DiscardUnknown() {
+	xxx_messageInfo_MultiSigTxOwner.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MultiSigTxOwner proto.InternalMessageInfo
+
+func (m *MultiSigTxOwner) GetMultiSigAddr() string {
+	if m != nil {
+		return m.MultiSigAddr
+	}
+	return ""
+}
+
+func (m *MultiSigTxOwner) GetTxid() uint64 {
+	if m != nil {
+		return m.Txid
+	}
+	return 0
+}
+
+func (m *MultiSigTxOwner) GetConfirmedOwner() *Owner {
+	if m != nil {
+		return m.ConfirmedOwner
+	}
+	return nil
+}
+
+type Uint64 struct {
+	Data                 uint64   `protobuf:"varint,1,opt,name=data,proto3" json:"data,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *Uint64) Reset()         { *m = Uint64{} }
+func (m *Uint64) String() string { return proto.CompactTextString(m) }
+func (*Uint64) ProtoMessage()    {}
+func (*Uint64) Descriptor() ([]byte, []int) {
+	return fileDescriptor_62b8b91adf3febfa, []int{34}
+}
+
+func (m *Uint64) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Uint64.Unmarshal(m, b)
+}
+func (m *Uint64) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Uint64.Marshal(b, m, deterministic)
+}
+func (m *Uint64) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Uint64.Merge(m, src)
+}
+func (m *Uint64) XXX_Size() int {
+	return xxx_messageInfo_Uint64.Size(m)
+}
+func (m *Uint64) XXX_DiscardUnknown() {
+	xxx_messageInfo_Uint64.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Uint64 proto.InternalMessageInfo
+
+func (m *Uint64) GetData() uint64 {
+	if m != nil {
+		return m.Data
+	}
+	return 0
+}
+
+//记录账户收到固定资产的数量
+type AccountAssets struct {
+	MultiSigAddr         string   `protobuf:"bytes,1,opt,name=multiSigAddr,proto3" json:"multiSigAddr,omitempty"`
+	Assets               *Assets  `protobuf:"bytes,2,opt,name=assets,proto3" json:"assets,omitempty"`
+	Amount               int64    `protobuf:"varint,3,opt,name=amount,proto3" json:"amount,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *AccountAssets) Reset()         { *m = AccountAssets{} }
+func (m *AccountAssets) String() string { return proto.CompactTextString(m) }
+func (*AccountAssets) ProtoMessage()    {}
+func (*AccountAssets) Descriptor() ([]byte, []int) {
+	return fileDescriptor_62b8b91adf3febfa, []int{35}
+}
+
+func (m *AccountAssets) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_AccountAssets.Unmarshal(m, b)
+}
+func (m *AccountAssets) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_AccountAssets.Marshal(b, m, deterministic)
+}
+func (m *AccountAssets) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_AccountAssets.Merge(m, src)
+}
+func (m *AccountAssets) XXX_Size() int {
+	return xxx_messageInfo_AccountAssets.Size(m)
+}
+func (m *AccountAssets) XXX_DiscardUnknown() {
+	xxx_messageInfo_AccountAssets.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_AccountAssets proto.InternalMessageInfo
+
+func (m *AccountAssets) GetMultiSigAddr() string {
+	if m != nil {
+		return m.MultiSigAddr
+	}
+	return ""
+}
+
+func (m *AccountAssets) GetAssets() *Assets {
+	if m != nil {
+		return m.Assets
+	}
+	return nil
+}
+
+func (m *AccountAssets) GetAmount() int64 {
+	if m != nil {
+		return m.Amount
+	}
+	return 0
+}
+
+//获取多重签名账户上的指定资产或者所有资产
+type ReqAccAssets struct {
+	MultiSigAddr         string   `protobuf:"bytes,1,opt,name=multiSigAddr,proto3" json:"multiSigAddr,omitempty"`
+	Assets               *Assets  `protobuf:"bytes,2,opt,name=assets,proto3" json:"assets,omitempty"`
+	IsAll                bool     `protobuf:"varint,3,opt,name=isAll,proto3" json:"isAll,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *ReqAccAssets) Reset()         { *m = ReqAccAssets{} }
+func (m *ReqAccAssets) String() string { return proto.CompactTextString(m) }
+func (*ReqAccAssets) ProtoMessage()    {}
+func (*ReqAccAssets) Descriptor() ([]byte, []int) {
+	return fileDescriptor_62b8b91adf3febfa, []int{36}
+}
+
+func (m *ReqAccAssets) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_ReqAccAssets.Unmarshal(m, b)
+}
+func (m *ReqAccAssets) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_ReqAccAssets.Marshal(b, m, deterministic)
+}
+func (m *ReqAccAssets) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ReqAccAssets.Merge(m, src)
+}
+func (m *ReqAccAssets) XXX_Size() int {
+	return xxx_messageInfo_ReqAccAssets.Size(m)
+}
+func (m *ReqAccAssets) XXX_DiscardUnknown() {
+	xxx_messageInfo_ReqAccAssets.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ReqAccAssets proto.InternalMessageInfo
+
+func (m *ReqAccAssets) GetMultiSigAddr() string {
+	if m != nil {
+		return m.MultiSigAddr
+	}
+	return ""
+}
+
+func (m *ReqAccAssets) GetAssets() *Assets {
+	if m != nil {
+		return m.Assets
+	}
+	return nil
+}
+
+func (m *ReqAccAssets) GetIsAll() bool {
+	if m != nil {
+		return m.IsAll
+	}
+	return false
+}
+
+type ReplyAccAssets struct {
+	AccAssets            []*AccAssets `protobuf:"bytes,1,rep,name=accAssets,proto3" json:"accAssets,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
+	XXX_unrecognized     []byte       `json:"-"`
+	XXX_sizecache        int32        `json:"-"`
+}
+
+func (m *ReplyAccAssets) Reset()         { *m = ReplyAccAssets{} }
+func (m *ReplyAccAssets) String() string { return proto.CompactTextString(m) }
+func (*ReplyAccAssets) ProtoMessage()    {}
+func (*ReplyAccAssets) Descriptor() ([]byte, []int) {
+	return fileDescriptor_62b8b91adf3febfa, []int{37}
+}
+
+func (m *ReplyAccAssets) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_ReplyAccAssets.Unmarshal(m, b)
+}
+func (m *ReplyAccAssets) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_ReplyAccAssets.Marshal(b, m, deterministic)
+}
+func (m *ReplyAccAssets) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ReplyAccAssets.Merge(m, src)
+}
+func (m *ReplyAccAssets) XXX_Size() int {
+	return xxx_messageInfo_ReplyAccAssets.Size(m)
+}
+func (m *ReplyAccAssets) XXX_DiscardUnknown() {
+	xxx_messageInfo_ReplyAccAssets.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ReplyAccAssets proto.InternalMessageInfo
+
+func (m *ReplyAccAssets) GetAccAssets() []*AccAssets {
+	if m != nil {
+		return m.AccAssets
+	}
+	return nil
+}
+
+//账户资产信息
+type AccAssets struct {
+	Assets               *Assets        `protobuf:"bytes,1,opt,name=assets,proto3" json:"assets,omitempty"`
+	RecvAmount           int64          `protobuf:"varint,2,opt,name=recvAmount,proto3" json:"recvAmount,omitempty"`
+	Account              *types.Account `protobuf:"bytes,3,opt,name=account,proto3" json:"account,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
+	XXX_unrecognized     []byte         `json:"-"`
+	XXX_sizecache        int32          `json:"-"`
+}
+
+func (m *AccAssets) Reset()         { *m = AccAssets{} }
+func (m *AccAssets) String() string { return proto.CompactTextString(m) }
+func (*AccAssets) ProtoMessage()    {}
+func (*AccAssets) Descriptor() ([]byte, []int) {
+	return fileDescriptor_62b8b91adf3febfa, []int{38}
+}
+
+func (m *AccAssets) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_AccAssets.Unmarshal(m, b)
+}
+func (m *AccAssets) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_AccAssets.Marshal(b, m, deterministic)
+}
+func (m *AccAssets) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_AccAssets.Merge(m, src)
+}
+func (m *AccAssets) XXX_Size() int {
+	return xxx_messageInfo_AccAssets.Size(m)
+}
+func (m *AccAssets) XXX_DiscardUnknown() {
+	xxx_messageInfo_AccAssets.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_AccAssets proto.InternalMessageInfo
+
+func (m *AccAssets) GetAssets() *Assets {
+	if m != nil {
+		return m.Assets
+	}
+	return nil
+}
+
+func (m *AccAssets) GetRecvAmount() int64 {
+	if m != nil {
+		return m.RecvAmount
+	}
+	return 0
+}
+
+func (m *AccAssets) GetAccount() *types.Account {
+	if m != nil {
+		return m.Account
+	}
+	return nil
+}
+
+type Assets struct {
+	Execer               string   `protobuf:"bytes,1,opt,name=execer,proto3" json:"execer,omitempty"`
+	Symbol               string   `protobuf:"bytes,2,opt,name=symbol,proto3" json:"symbol,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *Assets) Reset()         { *m = Assets{} }
+func (m *Assets) String() string { return proto.CompactTextString(m) }
+func (*Assets) ProtoMessage()    {}
+func (*Assets) Descriptor() ([]byte, []int) {
+	return fileDescriptor_62b8b91adf3febfa, []int{39}
+}
+
+func (m *Assets) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Assets.Unmarshal(m, b)
+}
+func (m *Assets) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Assets.Marshal(b, m, deterministic)
+}
+func (m *Assets) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Assets.Merge(m, src)
+}
+func (m *Assets) XXX_Size() int {
+	return xxx_messageInfo_Assets.Size(m)
+}
+func (m *Assets) XXX_DiscardUnknown() {
+	xxx_messageInfo_Assets.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Assets proto.InternalMessageInfo
+
+func (m *Assets) GetExecer() string {
+	if m != nil {
+		return m.Execer
+	}
+	return ""
+}
+
+func (m *Assets) GetSymbol() string {
+	if m != nil {
+		return m.Symbol
+	}
+	return ""
+}
+
+//账户地址列表
+type AccAddress struct {
+	Address              []string `protobuf:"bytes,1,rep,name=address,proto3" json:"address,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *AccAddress) Reset()         { *m = AccAddress{} }
+func (m *AccAddress) String() string { return proto.CompactTextString(m) }
+func (*AccAddress) ProtoMessage()    {}
+func (*AccAddress) Descriptor() ([]byte, []int) {
+	return fileDescriptor_62b8b91adf3febfa, []int{40}
+}
+
+func (m *AccAddress) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_AccAddress.Unmarshal(m, b)
+}
+func (m *AccAddress) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_AccAddress.Marshal(b, m, deterministic)
+}
+func (m *AccAddress) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_AccAddress.Merge(m, src)
+}
+func (m *AccAddress) XXX_Size() int {
+	return xxx_messageInfo_AccAddress.Size(m)
+}
+func (m *AccAddress) XXX_DiscardUnknown() {
+	xxx_messageInfo_AccAddress.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_AccAddress proto.InternalMessageInfo
+
+func (m *AccAddress) GetAddress() []string {
+	if m != nil {
+		return m.Address
+	}
+	return nil
+}
+
+func init() {
+	proto.RegisterType((*MultiSig)(nil), "types.MultiSig")
+	proto.RegisterType((*ConfirmedOwner)(nil), "types.ConfirmedOwner")
+	proto.RegisterType((*MultiSigTx)(nil), "types.MultiSigTx")
+	proto.RegisterType((*Owner)(nil), "types.Owner")
+	proto.RegisterType((*DailyLimit)(nil), "types.DailyLimit")
+	proto.RegisterType((*SymbolDailyLimit)(nil), "types.SymbolDailyLimit")
+	proto.RegisterType((*MultiSigAction)(nil), "types.MultiSigAction")
+	proto.RegisterType((*MultiSigAccCreate)(nil), "types.MultiSigAccCreate")
+	proto.RegisterType((*MultiSigOwnerOperate)(nil), "types.MultiSigOwnerOperate")
+	proto.RegisterType((*MultiSigAccOperate)(nil), "types.MultiSigAccOperate")
+	proto.RegisterType((*MultiSigExecTransferFrom)(nil), "types.MultiSigExecTransferFrom")
+	proto.RegisterType((*MultiSigExecTransferTo)(nil), "types.MultiSigExecTransferTo")
+	proto.RegisterType((*MultiSigConfirmTx)(nil), "types.MultiSigConfirmTx")
+	proto.RegisterType((*ReqMultiSigAccs)(nil), "types.ReqMultiSigAccs")
+	proto.RegisterType((*ReplyMultiSigAccs)(nil), "types.ReplyMultiSigAccs")
+	proto.RegisterType((*ReqMultiSigAccInfo)(nil), "types.ReqMultiSigAccInfo")
+	proto.RegisterType((*ReplyMultiSigAccInfo)(nil), "types.ReplyMultiSigAccInfo")
+	proto.RegisterType((*ReqMultiSigTxids)(nil), "types.ReqMultiSigTxids")
+	proto.RegisterType((*ReplyMultiSigTxids)(nil), "types.ReplyMultiSigTxids")
+	proto.RegisterType((*ReqMultiSigTxInfo)(nil), "types.ReqMultiSigTxInfo")
+	proto.RegisterType((*ReplyMultiSigTxInfo)(nil), "types.ReplyMultiSigTxInfo")
+	proto.RegisterType((*ReqMultiSigAccUnSpentToday)(nil), "types.ReqMultiSigAccUnSpentToday")
+	proto.RegisterType((*ReplyUnSpentAssets)(nil), "types.ReplyUnSpentAssets")
+	proto.RegisterType((*UnSpentAssets)(nil), "types.UnSpentAssets")
+	proto.RegisterType((*ReceiptMultiSig)(nil), "types.ReceiptMultiSig")
+	proto.RegisterType((*ReceiptOwnerAddOrDel)(nil), "types.ReceiptOwnerAddOrDel")
+	proto.RegisterType((*ReceiptOwnerModOrRep)(nil), "types.ReceiptOwnerModOrRep")
+	proto.RegisterType((*ReceiptWeightModify)(nil), "types.ReceiptWeightModify")
+	proto.RegisterType((*ReceiptDailyLimitOperate)(nil), "types.ReceiptDailyLimitOperate")
+	proto.RegisterType((*ReceiptConfirmTx)(nil), "types.ReceiptConfirmTx")
+	proto.RegisterType((*ReceiptAccDailyLimitUpdate)(nil), "types.ReceiptAccDailyLimitUpdate")
+	proto.RegisterType((*ReceiptMultiSigTx)(nil), "types.ReceiptMultiSigTx")
+	proto.RegisterType((*ReceiptTxCountUpdate)(nil), "types.ReceiptTxCountUpdate")
+	proto.RegisterType((*MultiSigTxOwner)(nil), "types.MultiSigTxOwner")
+	proto.RegisterType((*Uint64)(nil), "types.Uint64")
+	proto.RegisterType((*AccountAssets)(nil), "types.AccountAssets")
+	proto.RegisterType((*ReqAccAssets)(nil), "types.ReqAccAssets")
+	proto.RegisterType((*ReplyAccAssets)(nil), "types.ReplyAccAssets")
+	proto.RegisterType((*AccAssets)(nil), "types.AccAssets")
+	proto.RegisterType((*Assets)(nil), "types.Assets")
+	proto.RegisterType((*AccAddress)(nil), "types.AccAddress")
+}
+
+func init() { proto.RegisterFile("multisig.proto", fileDescriptor_62b8b91adf3febfa) }
+
+var fileDescriptor_62b8b91adf3febfa = []byte{
+	// 1535 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x18, 0xdd, 0x6e, 0xdc, 0x44,
+	0x37, 0xde, 0xbf, 0x64, 0xcf, 0x26, 0xdb, 0x64, 0xbe, 0x55, 0x3e, 0x13, 0x4a, 0x59, 0x8d, 0x4a,
+	0xb5, 0xaa, 0x20, 0x42, 0x69, 0xa1, 0x14, 0x09, 0xd4, 0xa5, 0x69, 0x95, 0xaa, 0xa4, 0x29, 0xd3,
+	0xad, 0x2a, 0x21, 0x71, 0xe1, 0xd8, 0x93, 0xd4, 0x62, 0xd7, 0xde, 0xda, 0xde, 0x64, 0x17, 0x90,
+	0xca, 0x25, 0x2f, 0x00, 0x17, 0x5c, 0x20, 0x1e, 0x82, 0x0b, 0x9e, 0x00, 0x5e, 0x80, 0xb7, 0xe0,
+	0x1a, 0x71, 0x8b, 0xe6, 0xcf, 0x9e, 0xb1, 0x9d, 0xc8, 0x95, 0x0a, 0x42, 0xdc, 0xf9, 0x9c, 0x39,
+	0x73, 0xfe, 0xff, 0x3c, 0xd0, 0x9d, 0xcc, 0xc6, 0x89, 0x1f, 0xfb, 0xc7, 0xdb, 0xd3, 0x28, 0x4c,
+	0x42, 0xd4, 0x4c, 0x16, 0x53, 0x1a, 0x6f, 0xad, 0x39, 0xae, 0x1b, 0xce, 0x82, 0x44, 0x60, 0xf1,
+	0xef, 0x16, 0xac, 0xec, 0x33, 0xc2, 0x47, 0xfe, 0x31, 0xba, 0x04, 0xe0, 0x46, 0xd4, 0x49, 0xe8,
+	0xd0, 0xf3, 0x22, 0xdb, 0xea, 0x5b, 0x83, 0x36, 0xd1, 0x30, 0x08, 0xc3, 0xea, 0x44, 0xd2, 0x72,
+	0x8a, 0x1a, 0xa7, 0x30, 0x70, 0xe8, 0x32, 0xb4, 0xc2, 0xd3, 0x80, 0x46, 0xb1, 0x5d, 0xef, 0xd7,
+	0x07, 0x9d, 0x9d, 0xd5, 0x6d, 0x2e, 0x77, 0xfb, 0x80, 0x21, 0x89, 0x3c, 0x43, 0xd7, 0xa0, 0xe3,
+	0x39, 0xfe, 0x78, 0xf1, 0xb1, 0x3f, 0xf1, 0x93, 0xd8, 0x6e, 0x70, 0xd2, 0x0d, 0x49, 0xba, 0x9b,
+	0x9e, 0x10, 0x9d, 0x0a, 0xd9, 0xb0, 0x9c, 0xcc, 0x6f, 0x33, 0xe5, 0xed, 0x66, 0xdf, 0x1a, 0x34,
+	0x88, 0x02, 0xd1, 0x15, 0xe8, 0x46, 0xf4, 0xd9, 0xcc, 0x8f, 0xa8, 0xf7, 0x84, 0xfa, 0xc7, 0x4f,
+	0x13, 0xbb, 0xc5, 0x09, 0x72, 0x58, 0x7c, 0x17, 0xba, 0xb7, 0xc3, 0xe0, 0xc8, 0x8f, 0x26, 0xd4,
+	0xe3, 0x0a, 0xa1, 0xeb, 0xd0, 0x75, 0x0d, 0x8c, 0x6d, 0x95, 0xa8, 0x9d, 0xa3, 0xc1, 0xbf, 0x58,
+	0x00, 0xca, 0x6b, 0xa3, 0x39, 0x42, 0xd0, 0x48, 0xe6, 0xbe, 0xc7, 0x3d, 0xd6, 0x20, 0xfc, 0x1b,
+	0x6d, 0x42, 0x2b, 0x99, 0xef, 0x39, 0xf1, 0x53, 0xe9, 0x25, 0x09, 0xa1, 0x2d, 0x58, 0xa1, 0x73,
+	0xea, 0xce, 0x12, 0xea, 0xd9, 0xf5, 0xbe, 0x35, 0x58, 0x21, 0x29, 0x2c, 0xee, 0x8c, 0x16, 0x53,
+	0x6a, 0x37, 0x38, 0x27, 0x09, 0x15, 0xfc, 0xde, 0x2c, 0xf1, 0x7b, 0xd1, 0x90, 0x56, 0x05, 0x43,
+	0x3e, 0x80, 0xa6, 0xf0, 0xc3, 0x45, 0x68, 0xf3, 0xd0, 0x68, 0x91, 0xcf, 0x10, 0x4c, 0xb1, 0x53,
+	0xe1, 0xd7, 0x9a, 0x50, 0x4c, 0x40, 0xf8, 0x3b, 0x0b, 0x20, 0x8b, 0x16, 0x23, 0x8b, 0x17, 0x93,
+	0xc3, 0x70, 0x2c, 0x39, 0x48, 0x88, 0xe1, 0x99, 0x8d, 0x54, 0x65, 0x8c, 0x84, 0x58, 0xbe, 0x65,
+	0xf1, 0xe5, 0xde, 0x68, 0x10, 0x0d, 0xc3, 0xce, 0xe3, 0x29, 0x0d, 0x92, 0x51, 0xe8, 0x39, 0x0b,
+	0xe9, 0x13, 0x0d, 0xc3, 0x12, 0x62, 0xec, 0xc4, 0xc9, 0xae, 0xb3, 0xe0, 0x2e, 0xa9, 0x13, 0x05,
+	0xe2, 0x43, 0x58, 0x7f, 0xc4, 0x65, 0xff, 0x7d, 0xda, 0xe1, 0x6f, 0x1b, 0xd0, 0x55, 0x49, 0x30,
+	0x74, 0x13, 0x3f, 0x0c, 0xd0, 0x1e, 0x6c, 0xa4, 0x41, 0x71, 0xdd, 0xdb, 0xbc, 0x72, 0xb8, 0xb4,
+	0xce, 0x8e, 0x2d, 0xe3, 0xb0, 0x9f, 0x3f, 0xdf, 0x5b, 0x22, 0xc5, 0x4b, 0xe8, 0x13, 0xe8, 0x29,
+	0x24, 0x0f, 0xd0, 0xc1, 0x94, 0x46, 0x8c, 0x59, 0x8d, 0x33, 0x7b, 0x35, 0xc7, 0x4c, 0x27, 0xd9,
+	0x5b, 0x22, 0xa5, 0x57, 0xd1, 0x7d, 0x40, 0x9a, 0x1c, 0xc5, 0xb0, 0xce, 0x19, 0xbe, 0x52, 0xd4,
+	0x2e, 0x63, 0x57, 0x72, 0x4d, 0xb7, 0x54, 0x56, 0xd4, 0x68, 0xce, 0x23, 0x54, 0xb4, 0x34, 0x3d,
+	0xd7, 0x2d, 0x4d, 0x91, 0xe8, 0x09, 0x6c, 0x2a, 0xe4, 0x9d, 0x39, 0x75, 0x47, 0x91, 0x13, 0xc4,
+	0x47, 0x34, 0x1a, 0x85, 0x3c, 0xa6, 0x9d, 0x9d, 0xd7, 0x72, 0xec, 0x4c, 0xa2, 0xbd, 0x25, 0x72,
+	0xc6, 0x75, 0xf4, 0x19, 0xd8, 0x65, 0x27, 0x77, 0xa3, 0x70, 0xc2, 0xdb, 0x43, 0x67, 0xe7, 0xf5,
+	0x73, 0x58, 0x33, 0xb2, 0xbd, 0x25, 0x72, 0x26, 0x0b, 0xd4, 0x85, 0xda, 0x68, 0x61, 0x2f, 0xf7,
+	0xad, 0x41, 0x93, 0xd4, 0x46, 0x8b, 0x8f, 0x96, 0xa1, 0x79, 0xe2, 0x8c, 0x67, 0x14, 0x7f, 0x6f,
+	0xc1, 0x46, 0x21, 0xca, 0x5a, 0x5f, 0xb4, 0xce, 0xe9, 0x8b, 0xc5, 0x46, 0x56, 0x2b, 0x6b, 0x64,
+	0xe8, 0x46, 0x21, 0x37, 0x3b, 0x3b, 0xff, 0x97, 0x1c, 0xf3, 0x89, 0x6f, 0x24, 0xed, 0xcf, 0x16,
+	0xf4, 0xca, 0xb2, 0x06, 0x0d, 0xe0, 0x82, 0x16, 0x66, 0xad, 0x0d, 0xe4, 0xd1, 0xac, 0x83, 0x85,
+	0x63, 0xd9, 0x63, 0x44, 0xc5, 0xa4, 0x30, 0x3b, 0x0b, 0xe8, 0xa9, 0x38, 0xab, 0x8b, 0x33, 0x05,
+	0xb3, 0x16, 0x13, 0xd0, 0x53, 0x69, 0x96, 0x28, 0xe6, 0x0c, 0x81, 0xfa, 0xd0, 0x09, 0x85, 0x2a,
+	0x77, 0xc7, 0xce, 0xb1, 0x6c, 0xf0, 0x3a, 0x0a, 0xff, 0x6a, 0x01, 0x2a, 0xe6, 0xe7, 0x0b, 0x28,
+	0x6e, 0x3a, 0xad, 0x56, 0xd9, 0x69, 0xe8, 0x4d, 0xd8, 0x08, 0xe8, 0x29, 0x31, 0x03, 0x23, 0x1a,
+	0x42, 0xf1, 0x20, 0x6f, 0x49, 0x83, 0x37, 0x79, 0xc3, 0x92, 0x1f, 0x2c, 0xb0, 0xcf, 0xca, 0xb9,
+	0xf3, 0xda, 0x94, 0x33, 0xe1, 0xc3, 0xaf, 0xc6, 0x7b, 0x9d, 0x84, 0xd8, 0xf0, 0x09, 0x42, 0x59,
+	0xc8, 0x6d, 0xc2, 0xbf, 0xd5, 0x90, 0x09, 0x9c, 0x89, 0x18, 0x25, 0x6d, 0x92, 0xc2, 0x2c, 0x6f,
+	0x93, 0x50, 0x8e, 0x90, 0x5a, 0x12, 0xb2, 0xfb, 0x47, 0xaa, 0x24, 0xda, 0x84, 0x7f, 0xe3, 0x6f,
+	0x2c, 0xd8, 0x2c, 0xaf, 0xb7, 0x7f, 0x5a, 0x3d, 0xfc, 0x65, 0x56, 0x4c, 0x59, 0xcf, 0xa8, 0x1e,
+	0x73, 0x3e, 0x9a, 0xef, 0x79, 0xb2, 0x8c, 0xf8, 0x37, 0xbb, 0x2d, 0xc7, 0xe0, 0x41, 0x44, 0xe8,
+	0x49, 0xf8, 0x39, 0x95, 0x93, 0x38, 0x8f, 0xc6, 0x37, 0xe1, 0x02, 0xa1, 0xcf, 0xb4, 0xa4, 0x8b,
+	0x51, 0x0f, 0x9a, 0x71, 0xe2, 0x44, 0x09, 0x17, 0x58, 0x27, 0x02, 0x40, 0xeb, 0x50, 0xa7, 0x81,
+	0x27, 0x4d, 0x67, 0x9f, 0xf8, 0x2d, 0xd8, 0x20, 0x74, 0x3a, 0x5e, 0x18, 0x97, 0x6d, 0x58, 0x76,
+	0x3c, 0x2f, 0xa2, 0xb1, 0xe8, 0x02, 0x6d, 0xa2, 0x40, 0xfc, 0x21, 0x20, 0x53, 0xd2, 0xbd, 0xe0,
+	0x28, 0xac, 0x6e, 0x27, 0xfe, 0xd3, 0x82, 0x5e, 0x5e, 0x1e, 0x67, 0xf1, 0x9f, 0xdf, 0xe9, 0x7e,
+	0xb4, 0x60, 0x5d, 0x73, 0xdd, 0x68, 0xee, 0x7b, 0x71, 0xc1, 0x2a, 0xab, 0xc4, 0xaa, 0x2d, 0x58,
+	0x61, 0xc9, 0x3e, 0xca, 0xd2, 0x23, 0x85, 0xf9, 0x26, 0x16, 0xf2, 0x93, 0xba, 0xdc, 0xc4, 0x38,
+	0xc4, 0xd4, 0x9d, 0xd2, 0xc0, 0xf3, 0x03, 0x55, 0xd7, 0x0a, 0x34, 0xf6, 0xba, 0xa6, 0xb9, 0xd7,
+	0xe1, 0x07, 0x2c, 0xb8, 0x5a, 0x6c, 0xaa, 0xeb, 0xd8, 0x83, 0x26, 0xdb, 0x26, 0x63, 0xbb, 0xd6,
+	0xaf, 0x0f, 0x1a, 0x44, 0x00, 0xf8, 0x3e, 0xcb, 0x2d, 0xcd, 0x62, 0x1e, 0xe8, 0x2a, 0xec, 0x4a,
+	0xaa, 0x01, 0x3f, 0x84, 0xff, 0xe5, 0x94, 0xe3, 0xec, 0x6e, 0xca, 0x1f, 0x88, 0x14, 0x23, 0xf7,
+	0x98, 0x8d, 0xdc, 0xcc, 0x1c, 0xcd, 0x49, 0x8e, 0x10, 0x4f, 0x61, 0xcb, 0xcc, 0xe5, 0xc7, 0xc1,
+	0xa3, 0x6c, 0x69, 0xab, 0xa2, 0xe7, 0x59, 0x2b, 0x59, 0xd6, 0x7c, 0xea, 0x7a, 0xf3, 0xc1, 0x0f,
+	0xa5, 0x83, 0xa5, 0xa0, 0x61, 0x1c, 0xd3, 0x24, 0x46, 0xef, 0xc3, 0xda, 0x4c, 0x47, 0xc8, 0xec,
+	0xed, 0x49, 0x0b, 0x0c, 0x62, 0x62, 0x92, 0xe2, 0x07, 0xb0, 0x66, 0x32, 0x7b, 0x03, 0x5a, 0x8e,
+	0xe0, 0x22, 0xfc, 0xb0, 0x26, 0xb9, 0xc8, 0xeb, 0xf2, 0x30, 0xd7, 0x06, 0x1b, 0xaa, 0x0d, 0xe2,
+	0x77, 0x58, 0x27, 0x71, 0xa9, 0x3f, 0x4d, 0xd2, 0xbf, 0xad, 0x0a, 0x8e, 0xc0, 0x5f, 0xb0, 0xaa,
+	0xe6, 0xd7, 0x0e, 0xe4, 0x32, 0x7e, 0x10, 0xed, 0xd2, 0x71, 0x25, 0x27, 0x62, 0x68, 0x86, 0xe9,
+	0x90, 0xce, 0x17, 0xad, 0x38, 0x62, 0x59, 0xeb, 0x48, 0x9e, 0xea, 0x6f, 0x44, 0xc1, 0xf8, 0x27,
+	0xcb, 0x14, 0xbe, 0x1f, 0x7a, 0xac, 0x31, 0x4e, 0x2b, 0x09, 0xbf, 0x0a, 0xed, 0x69, 0x44, 0x4f,
+	0x0e, 0xce, 0x54, 0x20, 0x3b, 0x46, 0x6f, 0xc3, 0xaa, 0x3b, 0x8b, 0x22, 0x1a, 0x24, 0xd9, 0xe2,
+	0x90, 0x27, 0x37, 0x28, 0x98, 0xda, 0x13, 0xa9, 0x8d, 0xac, 0xc3, 0x14, 0xc6, 0xcf, 0x59, 0x3e,
+	0x73, 0xad, 0x45, 0x83, 0xd8, 0x0f, 0x3d, 0xff, 0xa8, 0x5a, 0xda, 0x5d, 0x02, 0x60, 0x5a, 0x19,
+	0x9b, 0x97, 0x86, 0x41, 0x97, 0x61, 0x4d, 0xaa, 0x61, 0xec, 0x00, 0x26, 0x12, 0xff, 0x66, 0x81,
+	0x2d, 0x35, 0xc8, 0xba, 0x9e, 0xda, 0x56, 0xaa, 0xa8, 0x71, 0x13, 0xba, 0x4c, 0xe8, 0x6e, 0x7e,
+	0x57, 0x29, 0xe9, 0xa5, 0x39, 0x42, 0x74, 0x83, 0x6b, 0xb8, 0x9b, 0x5f, 0x0d, 0x4b, 0x6e, 0x9a,
+	0x74, 0x6c, 0x69, 0xe1, 0x81, 0x17, 0xde, 0x52, 0x4b, 0x8b, 0x86, 0xc2, 0x5f, 0xf3, 0x3e, 0xcb,
+	0xcd, 0xca, 0x06, 0xf1, 0xad, 0x6c, 0x40, 0x8d, 0xe6, 0xea, 0xff, 0x99, 0x49, 0xdc, 0x2c, 0xb4,
+	0x09, 0x11, 0xc7, 0x3c, 0x39, 0xba, 0x0a, 0xeb, 0xea, 0x9f, 0x34, 0x9d, 0xc6, 0x35, 0x2e, 0xbd,
+	0x80, 0x67, 0x19, 0xb9, 0x25, 0x55, 0x18, 0xba, 0x6e, 0xa6, 0xfd, 0xe3, 0xa9, 0xf7, 0x2f, 0xf6,
+	0x2d, 0xfe, 0xc3, 0x62, 0xfd, 0xda, 0x28, 0xfe, 0x97, 0xe2, 0x3a, 0x0c, 0xab, 0x4c, 0xc5, 0x3b,
+	0x6a, 0xec, 0x08, 0xb7, 0x19, 0x38, 0x16, 0x57, 0x77, 0x16, 0xdd, 0x31, 0x5f, 0x1c, 0x74, 0x14,
+	0xdb, 0x31, 0xe2, 0xd9, 0x21, 0x4b, 0xd1, 0x48, 0xc6, 0x55, 0x46, 0x3f, 0x8f, 0xd6, 0x9e, 0x34,
+	0x9a, 0xc6, 0x93, 0x46, 0xf6, 0x6c, 0xd1, 0xd2, 0x9f, 0x2d, 0xf0, 0xa7, 0x69, 0xff, 0x18, 0x89,
+	0x99, 0xfe, 0x02, 0x71, 0x62, 0x6b, 0xcb, 0x2c, 0x92, 0xf7, 0x54, 0x29, 0x66, 0x18, 0xfc, 0x1c,
+	0x2e, 0xec, 0x17, 0xdd, 0x51, 0x6d, 0x00, 0xfa, 0xda, 0x00, 0xf4, 0xbd, 0x92, 0x97, 0x93, 0xb2,
+	0x06, 0x94, 0x7f, 0x39, 0xb9, 0x08, 0xad, 0xc7, 0x7e, 0x90, 0xbc, 0x7b, 0x9d, 0xf1, 0xf4, 0x9c,
+	0xc4, 0x51, 0xaf, 0x3f, 0xec, 0x1b, 0x47, 0xb0, 0x36, 0x14, 0xef, 0x6c, 0x72, 0x7c, 0x54, 0x51,
+	0x2e, 0x1b, 0x31, 0xb5, 0x6a, 0x23, 0xa6, 0xae, 0x6f, 0xda, 0x38, 0x84, 0x55, 0x42, 0x9f, 0xb1,
+	0x85, 0xf0, 0xa5, 0x8b, 0xec, 0x41, 0xd3, 0x8f, 0x87, 0x63, 0x35, 0x23, 0x04, 0x80, 0x6f, 0x41,
+	0x97, 0x4f, 0xdd, 0x4c, 0xe4, 0x36, 0xb4, 0x1d, 0x05, 0xc8, 0xff, 0xdc, 0x75, 0xc5, 0x51, 0xe1,
+	0x49, 0x46, 0x82, 0xbf, 0x82, 0x76, 0x76, 0xb9, 0xe2, 0x84, 0xbd, 0x04, 0x10, 0x51, 0xf7, 0x64,
+	0xa8, 0xff, 0x6c, 0x68, 0x18, 0x34, 0x80, 0x65, 0xf9, 0xc4, 0x29, 0xe3, 0xd8, 0xcd, 0x34, 0x60,
+	0x58, 0xa2, 0x8e, 0xf1, 0x7b, 0xd0, 0x1a, 0xa6, 0x2e, 0x95, 0xfb, 0x86, 0x75, 0xc6, 0xbe, 0x51,
+	0x33, 0xf6, 0x8d, 0x2b, 0x00, 0x72, 0xf1, 0xa6, 0xf1, 0x39, 0x5b, 0xfd, 0x61, 0x8b, 0x3f, 0xb2,
+	0x5e, 0xfb, 0x2b, 0x00, 0x00, 0xff, 0xff, 0x6c, 0xd0, 0xe8, 0xee, 0x8c, 0x15, 0x00, 0x00,
+}

plugin/dapp/multisig/types/types.go

+// Copyright Fuzamei Corp. 2018 All Rights Reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package types
+
+import (
+	"reflect"
+
+	"github.com/33cn/chain33/types"
+)
+
+func init() {
+	types.AllowUserExec = append(types.AllowUserExec, []byte(MultiSigX))
+	types.RegistorExecutor(MultiSigX, NewType())
+	types.RegisterDappFork(MultiSigX, "Enable", 0)
+}
+
+// MultiSigType multisig合约结构体
+type MultiSigType struct {
+	types.ExecTypeBase
+}
+
+// NewType new一个新的multisig合约实例
+func NewType() *MultiSigType {
+	c := &MultiSigType{}
+	c.SetChild(c)
+	return c
+}
+
+//GetPayload 获取交易payload的结构体信息：也就是multisig.pb.go中定义的具体交易类型结构体
+func (m *MultiSigType) GetPayload() types.Message {
+	return &MultiSigAction{}
+}
+
+//GetName 获取合约name
+func (m *MultiSigType) GetName() string {
+	return MultiSigX
+}
+
+//GetTypeMap 获取处理具体交易的接口函数，也就是exec.go中的函数实现，去掉EXEC_
+func (m *MultiSigType) GetTypeMap() map[string]int32 {
+	return map[string]int32{
+		"MultiSigAccCreate":        ActionMultiSigAccCreate,
+		"MultiSigOwnerOperate":     ActionMultiSigOwnerOperate,
+		"MultiSigAccOperate":       ActionMultiSigAccOperate,
+		"MultiSigConfirmTx":        ActionMultiSigConfirmTx,
+		"MultiSigExecTransferTo":   ActionMultiSigExecTransferTo,
+		"MultiSigExecTransferFrom": ActionMultiSigExecTransferFrom,
+	}
+}
+
+//GetLogMap 获取具体执行Receiptlog对应的结构体：
+func (m *MultiSigType) GetLogMap() map[int64]*types.LogInfo {
+	return map[int64]*types.LogInfo{
+		TyLogMultiSigAccCreate: {Ty: reflect.TypeOf(MultiSig{}), Name: "LogMultiSigAccCreate"},
+
+		TyLogMultiSigOwnerAdd:     {Ty: reflect.TypeOf(ReceiptOwnerAddOrDel{}), Name: "LogMultiSigOwnerAdd"},
+		TyLogMultiSigOwnerDel:     {Ty: reflect.TypeOf(ReceiptOwnerAddOrDel{}), Name: "LogMultiSigOwnerDel"},
+		TyLogMultiSigOwnerModify:  {Ty: reflect.TypeOf(ReceiptOwnerModOrRep{}), Name: "LogMultiSigOwnerModify"},
+		TyLogMultiSigOwnerReplace: {Ty: reflect.TypeOf(ReceiptOwnerModOrRep{}), Name: "LogMultiSigOwnerReplace"},
+
+		TyLogMultiSigAccWeightModify:     {Ty: reflect.TypeOf(ReceiptWeightModify{}), Name: "LogMultiSigAccWeightModify"},
+		TyLogMultiSigAccDailyLimitAdd:    {Ty: reflect.TypeOf(ReceiptDailyLimitOperate{}), Name: "LogMultiSigAccDailyLimitAdd"},
+		TyLogMultiSigAccDailyLimitModify: {Ty: reflect.TypeOf(ReceiptDailyLimitOperate{}), Name: "LogMultiSigAccDailyLimitModify"},
+
+		TyLogMultiSigConfirmTx:       {Ty: reflect.TypeOf(ReceiptConfirmTx{}), Name: "LogMultiSigConfirmTx"},
+		TyLogMultiSigConfirmTxRevoke: {Ty: reflect.TypeOf(ReceiptConfirmTx{}), Name: "LogMultiSigConfirmTxRevoke"},
+
+		TyLogDailyLimitUpdate: {Ty: reflect.TypeOf(ReceiptAccDailyLimitUpdate{}), Name: "LogAccDailyLimitUpdate"},
+		TyLogMultiSigTx:       {Ty: reflect.TypeOf(ReceiptMultiSigTx{}), Name: "LogMultiSigAccTx"},
+		TyLogTxCountUpdate:    {Ty: reflect.TypeOf(ReceiptTxCountUpdate{}), Name: "LogTxCountUpdate"},
+	}
+}
+
+//DecodePayload 解码交易的Payload信息
+func (m MultiSigType) DecodePayload(tx *types.Transaction) (types.Message, error) {
+	var action MultiSigAction
+	err := types.Decode(tx.Payload, &action)
+	if err != nil {
+		return nil, err
+	}
+	return &action, nil
+}
+
+//ActionName 获取actionid对应的name
+func (m MultiSigType) ActionName(tx *types.Transaction) string {
+	var g MultiSigAction
+	err := types.Decode(tx.Payload, &g)
+	if err != nil {
+		return "unknown-MultiSig-action-err"
+	}
+	if g.Ty == ActionMultiSigAccCreate && g.GetMultiSigAccCreate() != nil {
+		return "MultiSigAccCreate"
+	} else if g.Ty == ActionMultiSigOwnerOperate && g.GetMultiSigOwnerOperate() != nil {
+		return "MultiSigOwnerOperate"
+	} else if g.Ty == ActionMultiSigAccOperate && g.GetMultiSigAccOperate() != nil {
+		return "MultiSigAccOperate"
+	} else if g.Ty == ActionMultiSigConfirmTx && g.GetMultiSigConfirmTx() != nil {
+		return "MultiSigTxConfirm"
+	} else if g.Ty == ActionMultiSigExecTransferTo && g.GetMultiSigExecTransferTo() != nil {
+		return "MultiSigExecTransfer"
+	} else if g.Ty == ActionMultiSigExecTransferFrom && g.GetMultiSigExecTransferFrom() != nil {
+		return "MultiSigAccExecTransfer"
+	}
+	return "unknown"
+}