Merge pull request #786 from mdj33/issue776_relay_support_token

plugin/dapp/paracross/cmd/build/testcase.sh

@@ -148,6 +148,9 @@ function para_transfer() {
     main_transfer2account "1Ka7EPFRqs3v9yreXG6qA4RQbNmbPJCZPj"
     main_transfer2account "1Luh4AziYyaC5zP3hUXtXFZS873xAxm6rH" 10
     main_transfer2account "1NNaYHkscJaLJ2wUrFNeh6cQXBS4TrFYeB" 10
+    #relay test
+    main_transfer2account "1G5Cjy8LuQex2fuYv3gzb7B8MxAnxLEqt3" 10
+    main_transfer2account "1EZKahMRfoMiKp1BewjWrQWoaJ9kmC4hum" 10
     #relay rpc test
     para_transfer2account "12qyocayNF7Lv6C9qW4avxs2E7U41fKSfv"
     para_transfer2account "1E5saiXVb9mW8wcWUUZjsHJPZs5GmdzuSY"
@@ -290,42 +293,49 @@ function token_create() {
     fi
 }
 
+#1G5Cjy8LuQex2fuYv3gzb7B8MxAnxLEqt3 also be used in relay rpc_test
 function token_transfer() {
     echo "=========== # 2.token transfer ============="
-    hash=$(${1} send token transfer -a 11 -s GD -t 1GGF8toZd96wCnfJngTwXZnWCBdWHYYvjw -k 0x6da92a632ab7deb67d38c0f6560bcfed28167998f6496db64c258d5e8393a81b)
+    hash=$(${1} send token transfer -a 100 -s GD -t 1G5Cjy8LuQex2fuYv3gzb7B8MxAnxLEqt3 -k 0x6da92a632ab7deb67d38c0f6560bcfed28167998f6496db64c258d5e8393a81b)
+    hash2=$(${1} send token transfer -a 100 -s GD -t 1EZKahMRfoMiKp1BewjWrQWoaJ9kmC4hum -k 0x6da92a632ab7deb67d38c0f6560bcfed28167998f6496db64c258d5e8393a81b)
     echo "${hash}"
+    echo "${hash2}"
     query_tx "${1}" "${hash}"
 
-    ${1} token balance -a 1GGF8toZd96wCnfJngTwXZnWCBdWHYYvjw -e token -s GD
-    balance=$(${1} token balance -a 1GGF8toZd96wCnfJngTwXZnWCBdWHYYvjw -e token -s GD | jq -r '.[]|.balance')
-    if [ "${balance}" != "11.0000" ]; then
+    ${1} token balance -a 1G5Cjy8LuQex2fuYv3gzb7B8MxAnxLEqt3 -e token -s GD
+    balance=$(${1} token balance -a 1G5Cjy8LuQex2fuYv3gzb7B8MxAnxLEqt3 -e token -s GD | jq -r '.[]|.balance')
+    balance2=$(${1} token balance -a 1EZKahMRfoMiKp1BewjWrQWoaJ9kmC4hum -e token -s GD | jq -r '.[]|.balance')
+    if [ "${balance}" != "100.0000" ] || [ "${balance2}" != "100.0000" ]; then
         echo "wrong para token transfer, should be 11.0000"
         exit 1
     fi
 
     echo "=========== # 3.token send exec ============="
-    hash=$(${1} send token send_exec -a 11 -s GD -e paracross -k 0x6da92a632ab7deb67d38c0f6560bcfed28167998f6496db64c258d5e8393a81b)
+    hash=$(${1} send token send_exec -a 100 -s GD -e relay -k 0x22968d29c6de695381a8719ef7bf00e2edb6cce500bb59a4fc73c41887610962)
+    hash2=$(${1} send token send_exec -a 100 -s GD -e relay -k ec9162ea5fc2f473ab8240619a0a0f495ba9e9e5d4d9c434b8794a68280236c4)
     echo "${hash}"
+    echo "${hash2}"
     query_tx "${1}" "${hash}"
 
-    # $ ./build/chain33-cli   exec addr  -e user.p.para.paracross
-    # 19WJJv96nKAU4sHFWqGmsqfjxd37jazqii
-    ${1} token balance -a 19WJJv96nKAU4sHFWqGmsqfjxd37jazqii -e token -s GD
-    balance=$(${1} token balance -a 19WJJv96nKAU4sHFWqGmsqfjxd37jazqii -e token -s GD | jq -r '.[]|.balance')
-    if [ "${balance}" != "11.0000" ]; then
-        echo "wrong para token send exec, should be 11.0000"
+    #user.p.para.relay addr
+    # 1464s4B8HbPdUZNR74EBWSH8QLGYgpjr2q
+    ${1} token balance -a 1G5Cjy8LuQex2fuYv3gzb7B8MxAnxLEqt3 -e token -s GD
+    balance=$(${1} token balance -a 1G5Cjy8LuQex2fuYv3gzb7B8MxAnxLEqt3 -e relay -s GD | jq -r '.[]|.balance')
+    balance2=$(${1} token balance -a 1EZKahMRfoMiKp1BewjWrQWoaJ9kmC4hum -e relay -s GD | jq -r '.[]|.balance')
+    if [ "${balance}" != "100.0000" ] || [ "${balance2}" != "100.0000" ]; then
+        echo "wrong para token send exec, should be 100.0000, balance=$balance,balance1=$balance2"
         exit 1
     fi
 
     echo "=========== # 4.token withdraw ============="
-    hash=$(${1} send token withdraw -a 11 -s GD -e paracross -k 0x6da92a632ab7deb67d38c0f6560bcfed28167998f6496db64c258d5e8393a81b)
+    hash=$(${1} send token withdraw -a 20 -s GD -e relay -k 0x22968d29c6de695381a8719ef7bf00e2edb6cce500bb59a4fc73c41887610962)
     echo "${hash}"
     query_tx "${1}" "${hash}"
 
-    ${1} token balance -a 19WJJv96nKAU4sHFWqGmsqfjxd37jazqii -e token -s GD
-    balance=$(${1} token balance -a 19WJJv96nKAU4sHFWqGmsqfjxd37jazqii -e token -s GD | jq -r '.[]|.balance')
-    if [ "${balance}" != "0.0000" ]; then
-        echo "wrong para token withdraw, should be 0.0000"
+    ${1} token balance -a 1G5Cjy8LuQex2fuYv3gzb7B8MxAnxLEqt3 -e relay -s GD
+    balance=$(${1} token balance -a 1G5Cjy8LuQex2fuYv3gzb7B8MxAnxLEqt3 -e relay -s GD | jq -r '.[]|.balance')
+    if [ "${balance}" != "80.0000" ]; then
+        echo "wrong para token withdraw, should be 80.0000"
         exit 1
     fi
 }

plugin/dapp/relay/cmd/build.sh

@@ -4,14 +4,14 @@ strpwd=$(pwd)
 strcmd=${strpwd##*dapp/}
 strapp=${strcmd%/cmd*}
 
-#OUT_DIR="${1}/$strapp"
-#SRC_RELAYD=github.com/33cn/plugin/plugin/dapp/relay/cmd/relayd
-#FLAG=$2
-#
-## shellcheck disable=SC2086,1072
-#go build -i ${FLAG} -v -o "${OUT_DIR}/relayd" "${SRC_RELAYD}"
-#cp ./relayd/relayd.toml "${OUT_DIR}/relayd.toml"
-#cp ./build/* "${OUT_DIR}"
+OUT_DIR="${1}/$strapp"
+SRC_RELAYD=github.com/33cn/plugin/plugin/dapp/relay/cmd/relayd
+FLAG=$2
+
+# shellcheck disable=SC2086,1072
+go build -i ${FLAG} -v -o "${OUT_DIR}/relayd" "${SRC_RELAYD}"
+cp ./relayd/relayd.toml "${OUT_DIR}/relayd.toml"
+cp ./build/* "${OUT_DIR}"
 
 OUT_TESTDIR="${1}/dapptest/$strapp"
 mkdir -p "${OUT_TESTDIR}"

plugin/dapp/relay/cmd/build/testcase.sh

@@ -93,8 +93,28 @@ function wait_btc_height() {
 }
 
 function relay_test() {
+    local sell_addr="1G5Cjy8LuQex2fuYv3gzb7B8MxAnxLEqt3"
+    local sell_priv="22968d29c6de695381a8719ef7bf00e2edb6cce500bb59a4fc73c41887610962"
+    local acct_addr="1EZKahMRfoMiKp1BewjWrQWoaJ9kmC4hum"
+    local acct_priv="ec9162ea5fc2f473ab8240619a0a0f495ba9e9e5d4d9c434b8794a68280236c4"
+    local buy_addr="1BafoGyuC3X6Sx5EhcVuHHfDgMNyjQGc5x"
+    local buy_priv="0xd04015639faa5bf740db756d8934003c4134865320e7eae65775be6cf30ff56f"
     echo "================relayd test========================"
+    echo "=========== # transfer to acct ============="
+    hash=$(${1} send coins transfer -a 1200 -t "$sell_addr" -n "transfer to sell" -k 12qyocayNF7Lv6C9qW4avxs2E7U41fKSfv)
+    echo "${hash}"
+    hash=$(${1} send coins transfer -a 600 -t "$acct_addr" -n "transfer to sell" -k 12qyocayNF7Lv6C9qW4avxs2E7U41fKSfv)
+    echo "${hash}"
+    hash=$(${1} send coins transfer -a 200 -t "$buy_addr" -n "transfer to buy" -k 12qyocayNF7Lv6C9qW4avxs2E7U41fKSfv)
+    echo "${hash}"
+
     block_wait "${1}" 2
+    acct1=$(${1} account balance -a "$sell_addr" | jq -r ".balance")
+    acct2=$(${1} account balance -a "$acct_addr" | jq -r ".balance")
+    if [ "${acct1}" == "0.0000" ] || [ "${acct2}" == "0.0000" ]; then
+        echo "wrong relay addr balance, should not be zero"
+        exit 1
+    fi
 
     times=100
     while true; do
@@ -122,149 +142,90 @@ function relay_test() {
     btcrcv_addr=$(${BTC_CTL} --rpcuser=root --rpcpass=1314 --simnet --wallet getaccountaddress "${newacct}")
     echo "btcrcvaddr=${btcrcv_addr}"
 
-    echo "=========== # get real BTY buy account ============="
-    real_buy_addr=$(${1} account list | jq -r '.wallets[] | select(.label=="node award") | .acc.addr')
-    echo "realbuyaddr=${real_buy_addr}"
-
     echo "=========== # transfer to relay ============="
-    hash=$(${1} send coins transfer -a 1000 -t 1rhRgzbz264eyJu7Ac63wepsm9TsEpwXM -n "transfer to relay" -k 12qyocayNF7Lv6C9qW4avxs2E7U41fKSfv)
+    hash=$(${1} send coins transfer -a 1000 -t 1rhRgzbz264eyJu7Ac63wepsm9TsEpwXM -n "transfer to relay" -k "$sell_priv")
     echo "${hash}"
-    hash=$(${1} send coins transfer -a 1000 -t 14KEKbYtKKQm4wMthSK9J4La4nAiidGozt -n "transfer to accept addr" -k 12qyocayNF7Lv6C9qW4avxs2E7U41fKSfv)
+    hash=$(${1} send coins transfer -a 500 -t 1rhRgzbz264eyJu7Ac63wepsm9TsEpwXM -n "send to relay" -k "$acct_priv")
     echo "${hash}"
-    hash=$(${1} send coins transfer -a 200 -t "${real_buy_addr}" -n "transfer to accept addr" -k 12qyocayNF7Lv6C9qW4avxs2E7U41fKSfv)
+    hash=$(${1} send coins transfer -a 100 -t 1rhRgzbz264eyJu7Ac63wepsm9TsEpwXM -n "send to relay" -k "${buy_priv}")
     echo "${hash}"
 
     block_wait "${1}" 1
-    before=$(${1} account balance -a 12qyocayNF7Lv6C9qW4avxs2E7U41fKSfv -e relay | jq -r ".balance")
+    before=$(${1} account balance -a "$sell_addr" -e relay | jq -r ".balance")
     if [ "${before}" == "0.0000" ]; then
         echo "wrong relay addr balance, should not be zero"
         exit 1
     fi
-    before=$(${1} account balance -a 14KEKbYtKKQm4wMthSK9J4La4nAiidGozt -e coins | jq -r ".balance")
-    if [ "${before}" == "0.0000" ]; then
-        echo "wrong accept addr balance, should not be zero"
-        exit 1
-    fi
-    before=$(${1} account balance -a "${real_buy_addr}" -e coins | jq -r ".balance")
-    if [ "${before}" == "0.0000" ]; then
-        echo "wrong real accept addr balance, should not be zero"
-        exit 1
-    fi
 
     echo "=========== # create buy order ============="
-    buy_hash=$(${1} send relay create -m 2.99 -o 0 -c BTC -a 1Am9UTGfdnxabvcywYG2hvzr6qK8T3oUZT -b 200 -k 12qyocayNF7Lv6C9qW4avxs2E7U41fKSfv)
+    buy_hash=$(${1} send relay create -m 2.99 -o 0 -c BTC -a 1Am9UTGfdnxabvcywYG2hvzr6qK8T3oUZT -b 200 -k "$sell_priv")
     echo "${buy_hash}"
     echo "=========== # create sell order ============="
-    sell_hash=$(${1} send relay create -m 2.99 -o 1 -c BTC -a 2Am9UTGfdnxabvcywYG2hvzr6qK8T3oUZT -b 200 -k 12qyocayNF7Lv6C9qW4avxs2E7U41fKSfv)
+    sell_hash=$(${1} send relay create -m 2.99 -o 1 -c BTC -a 2Am9UTGfdnxabvcywYG2hvzr6qK8T3oUZT -b 200 -k "$sell_priv")
     echo "${sell_hash}"
     echo "=========== # create real buy order ============="
-    realbuy_hash=$(${1} send relay create -m 10 -o 0 -c BTC -a "${btcrcv_addr}" -b 200 -k 12qyocayNF7Lv6C9qW4avxs2E7U41fKSfv)
+    realbuy_hash=$(${1} send relay create -m 10 -o 0 -c BTC -a "${btcrcv_addr}" -b 200 -k "$sell_priv")
     echo "${realbuy_hash}"
-    echo "=========== # transfer to relay ============="
-    hash=$(${1} send coins transfer -a 300 -t 1rhRgzbz264eyJu7Ac63wepsm9TsEpwXM -n "send to relay" -k 14KEKbYtKKQm4wMthSK9J4La4nAiidGozt)
-    echo "${hash}"
-    hash=$(${1} send coins transfer -a 100 -t 1rhRgzbz264eyJu7Ac63wepsm9TsEpwXM -n "send to relay" -k "${real_buy_addr}")
-    echo "${hash}"
 
     block_wait "${1}" 1
 
-    coinaddr=$(${1} tx query -s "${buy_hash}" | jq -r ".receipt.logs[2].log.coinAddr")
-    if [ "${coinaddr}" != "1Am9UTGfdnxabvcywYG2hvzr6qK8T3oUZT" ]; then
-        ${1} tx query -s "${buy_hash}"
-        echo "wrong create order to coinaddr"
-        exit 1
-    fi
-    buy_id=$(${1} tx query -s "${buy_hash}" | jq -r ".receipt.logs[2].log.orderId")
-    if [ -z "${buy_id}" ]; then
-        echo "wrong buy id"
-        exit 1
-    fi
-    oper=$(${1} tx query -s "${buy_hash}" | jq -r ".receipt.logs[2].log.coinOperation")
-    if [ "${oper}" != "buy" ]; then
-        echo "wrong buy operation"
-        exit 1
-    fi
+    #    coinaddr=$(${1} tx query -s "${buy_hash}" | jq -r ".receipt.logs[2].log.xAddr")
+    #    if [ "${coinaddr}" != "1Am9UTGfdnxabvcywYG2hvzr6qK8T3oUZT" ]; then
+    #        ${1} tx query -s "${buy_hash}"
+    #        echo "wrong create order to coinaddr"
+    #        exit 1
+    #    fi
+    #    buy_id=$(${1} tx query -s "${buy_hash}" | jq -r ".receipt.logs[2].log.orderId")
+    #    if [ -z "${buy_id}" ]; then
+    #        echo "wrong buy id"
+    #        exit 1
+    #    fi
 
     status=$(${1} tx query -s "${sell_hash}" | jq -r ".receipt.logs[2].log.curStatus")
     if [ "${status}" != "pending" ]; then
         echo "wrong create sell order status"
         exit 1
     fi
-    sell_id=$(${1} tx query -s "${sell_hash}" | jq -r ".receipt.logs[2].log.orderId")
-    if [ -z "${sell_id}" ]; then
-        echo "wrong sell id"
-        exit 1
-    fi
-    oper=$(${1} tx query -s "${sell_hash}" | jq -r ".receipt.logs[2].log.coinOperation")
-    if [ "${oper}" != "sell" ]; then
-        echo "wrong sell operation"
-        exit 1
-    fi
-    realbuy_id=$(${1} tx query -s "${realbuy_hash}" | jq -r ".receipt.logs[2].log.orderId")
-    if [ -z "${realbuy_id}" ]; then
-        echo "wrong realbuy_id "
-        exit 1
-    fi
-    before=$(${1} account balance -a 14KEKbYtKKQm4wMthSK9J4La4nAiidGozt -e relay | jq -r ".balance")
-    if [ "${before}" == "0.0000" ]; then
-        echo "wrong relay balance, should not be zero"
-        exit 1
-    fi
-    before=$(${1} account balance -a "${real_buy_addr}" -e relay | jq -r ".balance")
-    if [ "${before}" != "100.0000" ]; then
-        echo "wrong relay real buy balance, should be 100"
+
+    ${1} relay status -s 1
+    num=$(${1} relay status -s 1 | jq -sr '.|length')
+    if [ "${num}" != 3 ]; then
+        echo "wrong create orders num"
         exit 1
     fi
 
-    id=$(${1} relay status -s 1 | jq -sr '.[] | select(.coinoperation=="buy")| select(.coinaddr=="1Am9UTGfdnxabvcywYG2hvzr6qK8T3oUZT") |.orderid')
-    if [ "${id}" != "${buy_id}" ]; then
+    id=$(${1} relay status -s 1 | jq -sr '.[] | select(.coinoperation==0)| select(.coinaddr=="1Am9UTGfdnxabvcywYG2hvzr6qK8T3oUZT") |.orderid')
+    if [ "${id}" != "${buy_hash}" ]; then
         echo "wrong relay status buy order id"
         exit 1
     fi
-    id=$(${1} relay status -s 1 | jq -sr '.[] | select(.coinoperation=="buy")| select(.coinamount=="10.0000") |.orderid')
-    if [ "${id}" != "${realbuy_id}" ]; then
+    id=$(${1} relay status -s 1 | jq -sr '.[] | select(.coinoperation==0)| select(.coinamount=="10.0000") |.orderid')
+    if [ "${id}" != "${realbuy_hash}" ]; then
         echo "wrong relay status real buy order id"
         exit 1
     fi
 
-    id=$(${1} relay status -s 1 | jq -sr '.[] | select(.coinoperation=="sell")|.orderid')
-    if [ "${id}" != "${sell_id}" ]; then
+    id=$(${1} relay status -s 1 | jq -sr '.[] | select(.coinoperation==1)|.orderid')
+    if [ "${id}" != "${sell_hash}" ]; then
         echo "wrong relay status sell order id"
         exit 1
     fi
 
     echo "=========== # accept buy order ============="
-    buy_hash=$(${1} send relay accept -o "${buy_id}" -a 1Am9UTGfdnxabvcywYG2hvzr6qK8T3oUZT -k 14KEKbYtKKQm4wMthSK9J4La4nAiidGozt)
-    echo "${buy_hash}"
+    acct_buy_hash=$(${1} send relay accept -o "${buy_hash}" -a 1Am9UTGfdnxabvcywYG2hvzr6qK8T3oUZT -k "$acct_priv")
+    echo "${acct_buy_hash}"
     echo "=========== # accept real buy order ============="
-    realbuy_hash=$(${1} send relay accept -o "${realbuy_id}" -a 1Am9UTGfdnxabvcywYG2hvzr6qK8T3oUZT -k "${real_buy_addr}")
-    echo "${realbuy_hash}"
+    acct_realbuy_hash=$(${1} send relay accept -o "${realbuy_hash}" -a 1Am9UTGfdnxabvcywYG2hvzr6qK8T3oUZT -k "${buy_priv}")
+    echo "${acct_realbuy_hash}"
     echo "=========== # accept sell order ============="
-    sell_hash=$(${1} send relay accept -o "${sell_id}" -a 1Am9UTGfdnxabvcywYG2hvzr6qK8T3oUZT -k 14KEKbYtKKQm4wMthSK9J4La4nAiidGozt)
-    echo "${sell_hash}"
+    acct_sell_hash=$(${1} send relay accept -o "${sell_hash}" -a 1Am9UTGfdnxabvcywYG2hvzr6qK8T3oUZT -k "$acct_priv")
+    echo "${acct_sell_hash}"
     block_wait "${1}" 1
 
-    frozen=$(${1} tx query -s "${buy_hash}" | jq -r ".receipt.logs[1].log.current.frozen")
-    if [ "${frozen}" != "10000000000" ]; then
-        echo "wrong buy frozen account, should be 100"
-        ${1} tx query -s "${buy_hash}"
-        exit 1
-    fi
-
-    id=$(${1} relay status -s 2 | jq -sr '.[] | select(.coinoperation=="buy") | select(.coinaddr=="1Am9UTGfdnxabvcywYG2hvzr6qK8T3oUZT") |.orderid')
-    if [ "${id}" != "${buy_id}" ]; then
-        echo "wrong relay status buy order id"
-        exit 1
-    fi
-    id=$(${1} relay status -s 2 | jq -sr '.[] | select(.coinoperation=="buy")| select(.coinamount=="10.0000")|.orderid')
-    if [ "${id}" != "${realbuy_id}" ]; then
-        echo "wrong relay status real buy order id"
-        exit 1
-    fi
-
-    id=$(${1} relay status -s 2 | jq -sr '.[] | select(.coinoperation=="sell")|.orderid')
-    if [ "${id}" != "${sell_id}" ]; then
-        echo "wrong relay status sell order id"
+    ${1} relay status -s 2
+    num=$(${1} relay status -s 2 | jq -sr '.|length')
+    if [ "${num}" != 3 ]; then
+        echo "wrong accept orders num"
         exit 1
     fi
 
@@ -286,7 +247,7 @@ function relay_test() {
     wait_btc_height "${1}" $((current + 80 + 4))
 
     echo "=========== # unlock buy order ==========="
-    acceptHeight=$(${1} tx query -s "${buy_hash}" | jq -r ".receipt.logs[2].log.coinHeight")
+    acceptHeight=$(${1} tx query -s "${acct_buy_hash}" | jq -r ".receipt.logs[2].log.xHeight")
     if [ "${acceptHeight}" -lt "${btc_cur_height}" ]; then
         echo "accept height less previous height"
         exit 1
@@ -294,32 +255,32 @@ function relay_test() {
 
     wait_btc_height "${1}" $((acceptHeight + 72))
 
-    revoke_hash=$(${1} send relay revoke -a 0 -t 1 -i "${buy_id}" -k 14KEKbYtKKQm4wMthSK9J4La4nAiidGozt)
+    revoke_hash=$(${1} send relay revoke -a 0 -t 1 -i "${buy_hash}" -k "$acct_priv")
     echo "${revoke_hash}"
     echo "=========== # confirm real buy order ============="
-    confirm_hash=$(${1} send relay confirm -t "${btc_tx_hash}" -o "${realbuy_id}" -k "${real_buy_addr}")
+    confirm_hash=$(${1} send relay confirm -t "${btc_tx_hash}" -o "${realbuy_hash}" -k "${buy_priv}")
     echo "${confirm_hash}"
     echo "=========== # confirm sell order ============="
-    confirm_hash=$(${1} send relay confirm -t 6359f0868171b1d194cbee1af2f16ea598ae8fad666d9b012c8ed2b79a236ec4 -o "${sell_id}" -k 12qyocayNF7Lv6C9qW4avxs2E7U41fKSfv)
+    confirm_hash=$(${1} send relay confirm -t 6359f0868171b1d194cbee1af2f16ea598ae8fad666d9b012c8ed2b79a236ec4 -o "${sell_hash}" -k "$sell_priv")
     echo "${confirm_hash}"
 
     block_wait "${1}" 1
     echo "${revoke_hash}"
     ${1} tx query -s "${revoke_hash}"
 
-    id=$(${1} relay status -s 1 | jq -sr '.[] | select(.coinoperation=="buy")|.orderid')
-    if [ "${id}" != "${buy_id}" ]; then
+    id=$(${1} relay status -s 1 | jq -sr '.[] | select(.coinoperation==0)|.orderid')
+    if [ "${id}" != "${buy_hash}" ]; then
         echo "wrong relay pending status unlock buy order id"
         exit 1
     fi
 
-    id=$(${1} relay status -s 3 | jq -sr '.[] | select(.coinoperation=="buy")|.orderid')
-    if [ "${id}" != "${realbuy_id}" ]; then
+    id=$(${1} relay status -s 3 | jq -sr '.[] | select(.coinoperation==0)|.orderid')
+    if [ "${id}" != "${realbuy_hash}" ]; then
         echo "wrong relay status confirming real buy order id"
         exit 1
     fi
-    id=$(${1} relay status -s 3 | jq -sr '.[] | select(.coinoperation=="sell")|.orderid')
-    if [ "${id}" != "${sell_id}" ]; then
+    id=$(${1} relay status -s 3 | jq -sr '.[] | select(.coinoperation==1)|.orderid')
+    if [ "${id}" != "${sell_hash}" ]; then
         echo "wrong relay status confirming sell order id"
         exit 1
     fi
@@ -330,7 +291,7 @@ function relay_test() {
     wait_btc_height "${1}" $((current + 300))
 
     echo "=========== # unlock sell order ==="
-    confirmHeight=$(${1} tx query -s "${confirm_hash}" | jq -r ".receipt.logs[1].log.coinHeight")
+    confirmHeight=$(${1} tx query -s "${confirm_hash}" | jq -r ".receipt.logs[1].log.xHeight")
     if [ "${confirmHeight}" -lt "${btc_cur_height}" ]; then
         echo "wrong confirm height"
         exit 1
@@ -338,23 +299,21 @@ function relay_test() {
 
     wait_btc_height "${1}" $((confirmHeight + 288))
 
-    revoke_hash=$(${1} send relay revoke -a 0 -t 0 -i "${sell_id}" -k 12qyocayNF7Lv6C9qW4avxs2E7U41fKSfv)
+    revoke_hash=$(${1} send relay revoke -a 0 -t 0 -i "${sell_hash}" -k "$sell_priv")
     echo "${revoke_hash}"
     echo "=========== # test cancel create order ==="
-    cancel_hash=$(${1} send relay create -m 2.99 -o 0 -c BTC -a 1Am9UTGfdnxabvcywYG2hvzr6qK8T3oUZT -b 200 -k 14KEKbYtKKQm4wMthSK9J4La4nAiidGozt)
+    ${1} account balance -a "$acct_addr"
+    cancel_hash=$(${1} send relay create -m 2.99 -o 0 -c BTC -a 1Am9UTGfdnxabvcywYG2hvzr6qK8T3oUZT -b 20 -k "$acct_priv")
     echo "${cancel_hash}"
 
     block_wait "${1}" 1
     echo "${revoke_hash}"
     ${1} tx query -s "${revoke_hash}"
+    echo "${cancel_hash}"
+    ${1} tx query -s "${cancel_hash}"
 
-    cancel_id=$(${1} tx query -s "${cancel_hash}" | jq -r ".receipt.logs[2].log.orderId")
-    if [ -z "${cancel_id}" ]; then
-        echo "wrong buy id"
-        exit 1
-    fi
-    id=$(${1} relay status -s 1 | jq -sr '.[] | select(.coinoperation=="sell")| select(.address=="12qyocayNF7Lv6C9qW4avxs2E7U41fKSfv") | .orderid')
-    if [ "${id}" != "${sell_id}" ]; then
+    id=$(${1} relay status -s 1 | jq -sr '.[] | select(.coinoperation==1)| select(.address=="'"$sell_addr"'") | .orderid')
+    if [ "${id}" != "${sell_hash}" ]; then
         echo "wrong relay revoke order id "
         exit 1
     fi
@@ -367,8 +326,8 @@ function relay_test() {
     echo "=========== # check finish order ============="
     local count=30
     while true; do
-        id=$(${1} relay status -s 4 | jq -sr '.[] | select(.coinoperation=="buy")|.orderid')
-        if [ "${id}" == "${realbuy_id}" ]; then
+        id=$(${1} relay status -s 4 | jq -sr '.[] | select(.coinoperation==0)|.orderid')
+        if [ "${id}" == "${realbuy_hash}" ]; then
             break
         fi
         block_wait "${1}" 1
@@ -379,17 +338,16 @@ function relay_test() {
         fi
     done
 
-    before=$(${1} account balance -a "${real_buy_addr}" -e relay | jq -r ".balance")
+    before=$(${1} account balance -a "${buy_addr}" -e relay | jq -r ".balance")
     if [ "${before}" != "300.0000" ]; then
         echo "wrong relay real buy addr balance, should be 300"
         exit 1
     fi
 
     echo "=========== # cancel order ============="
-    hash=$(${1} send relay revoke -a 1 -t 0 -i "${cancel_id}" -k 14KEKbYtKKQm4wMthSK9J4La4nAiidGozt)
+    hash=$(${1} send relay revoke -a 1 -t 0 -i "${cancel_hash}" -k "$acct_priv")
     echo "${hash}"
     block_wait "${1}" 1
-    echo "${hash}"
     ${1} tx query -s "${hash}"
 
     status=$(${1} relay status -s 5 | jq -r ".status")
@@ -397,8 +355,8 @@ function relay_test() {
         echo "wrong relay order pending status"
         exit 1
     fi
-    id=$(${1} relay status -s 5 | jq -sr '.[] | select(.coinoperation=="buy")|.orderid')
-    if [ "${id}" != "${cancel_id}" ]; then
+    id=$(${1} relay status -s 5 | jq -sr '.[] | select(.coinoperation==0)|.orderid')
+    if [ "${id}" != "${cancel_hash}" ]; then
         echo "wrong relay status cancel order id"
         exit 1
     fi

plugin/dapp/relay/cmd/relayd/relayd.toml

@@ -10,8 +10,8 @@ syncSetup = 100
 syncSetupCount = 10
 
 [auth]
-# test private key
-privateKey = "4257D8692EF7FE13C68B65D6A52F03933DB2FA5CE8FAF210B5B8B80C721CED01"
+# test private key 1G5Cjy8LuQex2fuYv3gzb7B8MxAnxLEqt3
+privateKey = "22968d29c6de695381a8719ef7bf00e2edb6cce500bb59a4fc73c41887610962"
 publicKey = ""
 address = ""
 

plugin/dapp/relay/cmd/relayd/relayd/relayd.go

@@ -344,7 +344,7 @@ func (r *Relayd) dealOrder() {
 
 	for _, value := range result.GetOrders() {
 		// TODO save db ???
-		tx, err := r.btcClient.GetTransaction(value.CoinTxHash)
+		tx, err := r.btcClient.GetTransaction(value.XTxHash)
 		if err != nil {
 			log.Error("dealOrder", "dealOrder GetTransaction error: ", err)
 			continue

plugin/dapp/relay/cmd/relayd/relayd/relayd_test.go

@@ -11,6 +11,9 @@ import (
 	"github.com/33cn/chain33/common/address"
 	"github.com/33cn/chain33/common/crypto"
 	"github.com/33cn/chain33/types"
+	typesmocks "github.com/33cn/chain33/types/mocks"
+	types2 "github.com/33cn/plugin/plugin/dapp/relay/types"
+	"github.com/stretchr/testify/mock"
 )
 
 func TestGeneratePrivateKey(t *testing.T) {
@@ -28,3 +31,27 @@ func TestGeneratePrivateKey(t *testing.T) {
 	t.Log("publick key: ", common.ToHex(key.PubKey().Bytes()))
 	t.Log("    address: ", address.PubKeyToAddress(key.PubKey().Bytes()))
 }
+
+func TestDealOrder(t *testing.T) {
+	grpcClient := &typesmocks.Chain33Client{}
+	relayd := &Relayd{}
+	relayd.client33 = &Client33{}
+	relayd.client33.Chain33Client = grpcClient
+	relayd.btcClient = &btcdClient{
+		connConfig:          nil,
+		chainParams:         mainNetParams.Params,
+		reconnectAttempts:   3,
+		enqueueNotification: make(chan interface{}),
+		dequeueNotification: make(chan interface{}),
+		currentBlock:        make(chan *blockStamp),
+		quit:                make(chan struct{}),
+	}
+
+	relayorder := &types2.RelayOrder{Id: string("id"), XTxHash: "hash"}
+	rst := &types2.QueryRelayOrderResult{Orders: []*types2.RelayOrder{relayorder}}
+	reply := &types.Reply{}
+	reply.Msg = types.Encode(rst)
+	grpcClient.On("QueryChain", mock.Anything, mock.Anything).Return(reply, nil).Once()
+	grpcClient.On("SendTransaction", mock.Anything, mock.Anything).Return(nil, nil).Once()
+	relayd.dealOrder()
+}

plugin/dapp/relay/cmd/test/test-rpc.sh

@@ -5,20 +5,24 @@ source ../dapp-test-common.sh
 
 MAIN_HTTP=""
 
+relay_parallel_exec=""
+
 relay_CreateRawRelaySaveBTCHeadTx() {
-    local req='{"method":"relay.CreateRawRelaySaveBTCHeadTx","params":[{"hash":"5e7d9c599cd040ec2ba53f4dee28028710be8c135e779f65c56feadaae34c3f2","height":10,"version":536870912,"merkleRoot":"ab91cd4160e1379c337eee6b7a4bdbb7399d70268d86045aba150743c00c90b6","time":1530862108,"nonce":0,"bits":545259519,"previousHash":"604efe53975ab06cad8748fd703ad5bc960e8b752b2aae98f0f871a4a05abfc7","isReset":true}]}'
+    local req='{"method":"Chain33.CreateTransaction","params":[{"execer":"'"${relay_parallel_exec}"'","actionName":"BtcHeaders","payload":{"btcHeader":[{"hash":"5e7d9c599cd040ec2ba53f4dee28028710be8c135e779f65c56feadaae34c3f2","height":10,"version":536870912,"merkleRoot":"ab91cd4160e1379c337eee6b7a4bdbb7399d70268d86045aba150743c00c90b6","time":1530862108,"nonce":0,"bits":545259519,"previousHash":"604efe53975ab06cad8748fd703ad5bc960e8b752b2aae98f0f871a4a05abfc7","isReset":true}]}}]}'
     chain33_Http "$req" ${MAIN_HTTP} '(.error|not) and (.result != null)' "$FUNCNAME" ".result"
     chain33_SignAndSendTx "$RETURN_RESP" "0x22968d29c6de695381a8719ef7bf00e2edb6cce500bb59a4fc73c41887610962" "${MAIN_HTTP}"
 }
 
 relay_CreateRawRelaySaveBTCHeadTx_11() {
-    local req='{"method":"relay.CreateRawRelaySaveBTCHeadTx","params":[{"hash":"7b7a4a9b49db5a1162be515d380cd186e98c2bf0bb90f1145485d7c43343fc7c","height":11,"version":536870912,"merkleRoot":"cfa9b66696aea63b7266ffaa1cb4b96c8dd6959eaabf2eb14173f4adaa551f6f","time":1530862108,"nonce":1,"bits":545259519,"previousHash":"5e7d9c599cd040ec2ba53f4dee28028710be8c135e779f65c56feadaae34c3f2","isReset":false}]}'
+    local req='{"method":"Chain33.CreateTransaction","params":[{"execer":"'"${relay_parallel_exec}"'","actionName":"BtcHeaders","payload":{"btcHeader":[{"hash":"7b7a4a9b49db5a1162be515d380cd186e98c2bf0bb90f1145485d7c43343fc7c","height":11,"version":536870912,"merkleRoot":"cfa9b66696aea63b7266ffaa1cb4b96c8dd6959eaabf2eb14173f4adaa551f6f","time":1530862108,"nonce":1,"bits":545259519,"previousHash":"5e7d9c599cd040ec2ba53f4dee28028710be8c135e779f65c56feadaae34c3f2","isReset":false}]}}]}'
     chain33_Http "$req" ${MAIN_HTTP} '(.error|not) and (.result != null)' "$FUNCNAME" ".result"
     chain33_SignAndSendTx "$RETURN_RESP" "0x22968d29c6de695381a8719ef7bf00e2edb6cce500bb59a4fc73c41887610962" "${MAIN_HTTP}"
 }
 
 relay_CreateRawRelayOrderTx() {
-    local req='{"method":"relay.CreateRawRelayOrderTx","params":[{"operation":0,"coin":"BTC","amount":299000000,"addr":"1Am9UTGfdnxabvcywYG2hvzr6qK8T3oUZT","btyAmount":1000000000,"coinWaits":6}]}'
+    localCoinSymbol="$1"
+    localCoinExec="$2"
+    local req='{"method":"Chain33.CreateTransaction","params":[{"execer":"'"${relay_parallel_exec}"'","actionName":"Create","payload":{"operation":0,"xCoin":"BTC","xAmount":299000000,"xAddr":"1Am9UTGfdnxabvcywYG2hvzr6qK8T3oUZT","localCoinAmount":1000000000,"localCoinSymbol":"'"$localCoinSymbol"'","localCoinExec":"'"$localCoinExec"'","xBlockWaits":6}}]}'
     chain33_Http "$req" ${MAIN_HTTP} '(.error|not) and (.result != null)' "$FUNCNAME" ".result"
     chain33_SignAndSendTx "$RETURN_RESP" "0x22968d29c6de695381a8719ef7bf00e2edb6cce500bb59a4fc73c41887610962" "${MAIN_HTTP}"
 }
@@ -33,7 +37,7 @@ relay_CreateRawRelayAcceptTx() {
         exit 1
     fi
 
-    local req='{"method":"relay.CreateRawRelayAcceptTx","params":[{"orderId":"'"$id"'","coinAddr":"1Am9UTGfdnxabvcywYG2hvzr6qK8T3oUZT"}]}'
+    local req='{"method":"Chain33.CreateTransaction","params":[{"execer":"'"${relay_parallel_exec}"'","actionName":"Accept","payload":{"orderId":"'"$id"'","xAddr":"1Am9UTGfdnxabvcywYG2hvzr6qK8T3oUZT"}}]}'
     chain33_Http "$req" ${MAIN_HTTP} '(.error|not) and (.result != null)' "$FUNCNAME" ".result"
     chain33_SignAndSendTx "$RETURN_RESP" "0xec9162ea5fc2f473ab8240619a0a0f495ba9e9e5d4d9c434b8794a68280236c4" "${MAIN_HTTP}"
 }
@@ -48,7 +52,7 @@ relay_CreateRawRelayRevokeTx() {
         exit 1
     fi
 
-    local req='{"method":"relay.CreateRawRelayRevokeTx","params":[{"orderId":"'"$id"'","target":0,"action":1}]}'
+    local req='{"method":"Chain33.CreateTransaction","params":[{"execer":"'"${relay_parallel_exec}"'","actionName":"Revoke","payload":{"orderId":"'"$id"'","target":0,"action":1}}]}'
     chain33_Http "$req" ${MAIN_HTTP} '(.error|not) and (.result != null)' "$FUNCNAME" ".result"
     chain33_SignAndSendTx "$RETURN_RESP" "0x22968d29c6de695381a8719ef7bf00e2edb6cce500bb59a4fc73c41887610962" "${MAIN_HTTP}"
 }
@@ -63,7 +67,7 @@ relay_CreateRawRelayConfirmTx() {
         exit 1
     fi
 
-    local req='{"method":"relay.CreateRawRelayConfirmTx","params":[{"orderId":"'"$id"'","rawTx":"6359f0868171b1d194cbee1af2f16ea598ae8fad666d9b012c8ed2b79a236ec4"}]}'
+    local req='{"method":"Chain33.CreateTransaction","params":[{"execer":"'"${relay_parallel_exec}"'","actionName":"ConfirmTx","payload":{"orderId":"'"$id"'","txHash":"6359f0868171b1d194cbee1af2f16ea598ae8fad666d9b012c8ed2b79a236ec4"}}]}'
     chain33_Http "$req" ${MAIN_HTTP} '(.error|not) and (.result != null)' "$FUNCNAME" ".result"
     chain33_SignAndSendTx "$RETURN_RESP" "0xec9162ea5fc2f473ab8240619a0a0f495ba9e9e5d4d9c434b8794a68280236c4" "${MAIN_HTTP}"
 }
@@ -76,7 +80,7 @@ query_GetRelayOrderByStatus() {
 
 query_GetSellRelayOrder() {
     local req='{"method":"Chain33.Query", "params":[{"execer":"relay","funcName":"GetSellRelayOrder","payload":{"addr":"1G5Cjy8LuQex2fuYv3gzb7B8MxAnxLEqt3","status":"pending","coins":["BTC"],"pageNumber":0,"pageSize":0}}]}'
-    resok='(.error|not) and (.result.relayorders[0].status == "pending") and (.result.relayorders[0].coinOperation == 0) and (.result.relayorders[0].id != null)'
+    resok='(.error|not) and (.result.relayorders[0].status == "pending") and (.result.relayorders[0].operation == 0) and (.result.relayorders[0].id != null)'
     chain33_Http "$req" ${MAIN_HTTP} "$resok" "$FUNCNAME"
 }
 
@@ -100,8 +104,10 @@ init() {
     echo "ipara=$ispara"
     local relay_addr=""
     if [ "$ispara" == true ]; then
+        relay_parallel_exec="user.p.para.relay"
         relay_addr=$(curl -ksd '{"method":"Chain33.ConvertExectoAddr","params":[{"execname":"user.p.para.relay"}]}' ${MAIN_HTTP} | jq -r ".result")
     else
+        relay_parallel_exec="relay"
         relay_addr=$(curl -ksd '{"method":"Chain33.ConvertExectoAddr","params":[{"execname":"relay"}]}' ${MAIN_HTTP} | jq -r ".result")
     fi
     echo "relayaddr=$relay_addr"
@@ -146,7 +152,13 @@ function run_testcases() {
     relay_CreateRawRelaySaveBTCHeadTx
     query_GetBTCHeaderCurHeight
 
+    ispara=$(echo '"'"${MAIN_HTTP}"'"' | jq '.|contains("8901")')
+    if [ "$ispara" == true ]; then
+        relay_CreateRawRelayOrderTx "GD"
+    else
         relay_CreateRawRelayOrderTx
+    fi
+
     query_GetSellRelayOrder
     query_GetRelayOrderByStatus "pending"
 

plugin/dapp/relay/commands/relay.go

@@ -36,7 +36,6 @@ func RelayCmd() *cobra.Command {
 		CreateRawRelayAcceptTxCmd(),
 		CreateRawRevokeTxCmd(),
 		CreateRawRelayConfirmTxCmd(),
-		CreateRawRelayBtcHeaderCmd(),
 	)
 
 	return cmd
@@ -302,12 +301,12 @@ func parseRelayOrders(res ty.ReplyRelayOrders) {
 		show.OrderID = order.Id
 		show.Status = order.Status.String()
 		show.Creator = order.CreaterAddr
-		show.CoinOperation = ty.RelayOrderOperation[order.CoinOperation]
-		show.Amount = strconv.FormatFloat(float64(order.Amount)/float64(types.Coin), 'f', 4, 64)
-		show.Coin = order.Coin
-		show.CoinAddr = order.CoinAddr
-		show.CoinAmount = strconv.FormatFloat(float64(order.CoinAmount)/float64(types.Coin), 'f', 4, 64)
-		show.CoinWaits = order.CoinWaits
+		show.CoinOperation = order.Operation
+		show.Amount = strconv.FormatFloat(float64(order.LocalCoinAmount)/float64(types.Coin), 'f', 4, 64)
+		show.Coin = order.XCoin
+		show.CoinAddr = order.XAddr
+		show.CoinAmount = strconv.FormatFloat(float64(order.XAmount)/float64(types.Coin), 'f', 4, 64)
+		show.CoinWaits = order.XBlockWaits
 		show.CreateTime = order.CreateTime
 		show.AcceptAddr = order.AcceptAddr
 		show.AcceptTime = order.AcceptTime
@@ -315,6 +314,8 @@ func parseRelayOrders(res ty.ReplyRelayOrders) {
 		show.FinishTime = order.FinishTime
 		show.FinishTxHash = order.FinishTxHash
 		show.Height = order.Height
+		show.LocalCoinExec = order.LocalCoinExec
+		show.LocalCoinSym = order.LocalCoinSymbol
 
 		data, err := json.MarshalIndent(show, "", "    ")
 		if err != nil {
@@ -372,7 +373,7 @@ func addExchangeFlags(cmd *cobra.Command) {
 }
 
 func relayOrder(cmd *cobra.Command, args []string) {
-	rpcLaddr, _ := cmd.Flags().GetString("rpc_laddr")
+
 	oper, _ := cmd.Flags().GetUint32("operation")
 	coin, _ := cmd.Flags().GetString("coin")
 	coinamount, _ := cmd.Flags().GetFloat64("coin_amount")
@@ -389,15 +390,35 @@ func relayOrder(cmd *cobra.Command, args []string) {
 
 	params := &ty.RelayCreate{
 		Operation:       oper,
-		Amount:    coinUInt64 * 1e4,
-		Coin:      coin,
-		Addr:      coinaddr,
-		CoinWaits: coinwait,
-		BtyAmount: btyUInt64 * 1e4,
+		XAmount:         coinUInt64 * 1e4,
+		XCoin:           coin,
+		XAddr:           coinaddr,
+		XBlockWaits:     coinwait,
+		LocalCoinAmount: btyUInt64 * 1e4,
+	}
+
+	payLoad, err := json.Marshal(params)
+	if err != nil {
+		return
+	}
+
+	createTx(cmd, payLoad, "Create")
+
+}
+
+func createTx(cmd *cobra.Command, payLoad []byte, action string) {
+	title, _ := cmd.Flags().GetString("title")
+	cfg := types.GetCliSysParam(title)
+	rpcLaddr, _ := cmd.Flags().GetString("rpc_laddr")
+
+	pm := &rpctypes.CreateTxIn{
+		Execer:     cfg.ExecName(ty.RelayX),
+		ActionName: action,
+		Payload:    payLoad,
 	}
 
 	var res string
-	ctx := jsonclient.NewRPCCtx(rpcLaddr, "relay.CreateRawRelayOrderTx", params, &res)
+	ctx := jsonclient.NewRPCCtx(rpcLaddr, "Chain33.CreateTransaction", pm, &res)
 	ctx.RunWithoutMarshal()
 }
 
@@ -424,7 +445,6 @@ func addRelayAcceptFlags(cmd *cobra.Command) {
 }
 
 func relayAccept(cmd *cobra.Command, args []string) {
-	rpcLaddr, _ := cmd.Flags().GetString("rpc_laddr")
 	orderID, _ := cmd.Flags().GetString("order_id")
 	coinaddr, _ := cmd.Flags().GetString("coin_addr")
 	coinwait, _ := cmd.Flags().GetUint32("coin_wait")
@@ -435,12 +455,16 @@ func relayAccept(cmd *cobra.Command, args []string) {
 
 	params := &ty.RelayAccept{
 		OrderId:     orderID,
-		CoinAddr:  coinaddr,
-		CoinWaits: coinwait,
+		XAddr:       coinaddr,
+		XBlockWaits: coinwait,
 	}
-	var res string
-	ctx := jsonclient.NewRPCCtx(rpcLaddr, "relay.CreateRawRelayAcceptTx", params, &res)
-	ctx.RunWithoutMarshal()
+
+	payLoad, err := json.Marshal(params)
+	if err != nil {
+		return
+	}
+
+	createTx(cmd, payLoad, "Accept")
 }
 
 // CreateRawRevokeTxCmd revoke order
@@ -467,7 +491,6 @@ func addRevokeFlags(cmd *cobra.Command) {
 }
 
 func relayRevoke(cmd *cobra.Command, args []string) {
-	rpcLaddr, _ := cmd.Flags().GetString("rpc_laddr")
 	orderID, _ := cmd.Flags().GetString("order_id")
 	target, _ := cmd.Flags().GetUint32("target")
 	act, _ := cmd.Flags().GetUint32("action")
@@ -477,9 +500,13 @@ func relayRevoke(cmd *cobra.Command, args []string) {
 		Target:  target,
 		Action:  act,
 	}
-	var res string
-	ctx := jsonclient.NewRPCCtx(rpcLaddr, "relay.CreateRawRelayRevokeTx", params, &res)
-	ctx.RunWithoutMarshal()
+	payLoad, err := json.Marshal(params)
+	if err != nil {
+		return
+	}
+
+	createTx(cmd, payLoad, "Revoke")
+
 }
 
 // CreateRawRelayConfirmTxCmd confirm tx
@@ -503,7 +530,6 @@ func addConfirmFlags(cmd *cobra.Command) {
 }
 
 func relayConfirm(cmd *cobra.Command, args []string) {
-	rpcLaddr, _ := cmd.Flags().GetString("rpc_laddr")
 	orderID, _ := cmd.Flags().GetString("order_id")
 	txHash, _ := cmd.Flags().GetString("tx_hash")
 
@@ -511,56 +537,10 @@ func relayConfirm(cmd *cobra.Command, args []string) {
 		OrderId: orderID,
 		TxHash:  txHash,
 	}
-	var res string
-	ctx := jsonclient.NewRPCCtx(rpcLaddr, "relay.CreateRawRelayConfirmTx", params, &res)
-	ctx.RunWithoutMarshal()
-}
-
-// CreateRawRelayBtcHeaderCmd save btc header from cli
-func CreateRawRelayBtcHeaderCmd() *cobra.Command {
-	cmd := &cobra.Command{
-		Use:   "save_header",
-		Short: "save BTC header",
-		Run:   relaySaveBtcHead,
-	}
-	addSaveBtcHeadFlags(cmd)
-	return cmd
-}
-
-func addSaveBtcHeadFlags(cmd *cobra.Command) {
-	cmd.Flags().StringP("block_hash", "b", "", "block hash")
-	cmd.MarkFlagRequired("block_hash")
-
-	cmd.Flags().StringP("pre_hash", "p", "", "previous block hash")
-	cmd.MarkFlagRequired("pre_hash")
-
-	cmd.Flags().StringP("merkle_root", "m", "", "merkle root")
-	cmd.MarkFlagRequired("merkle_root")
-
-	cmd.Flags().Uint64P("height", "t", 0, "block height")
-	cmd.MarkFlagRequired("height")
-
-	cmd.Flags().Int32P("flag", "g", 0, "reset height and save from current height")
-
-}
-
-func relaySaveBtcHead(cmd *cobra.Command, args []string) {
-	rpcLaddr, _ := cmd.Flags().GetString("rpc_laddr")
-	blockhash, _ := cmd.Flags().GetString("block_hash")
-	prehash, _ := cmd.Flags().GetString("pre_hash")
-	merkleroot, _ := cmd.Flags().GetString("merkle_root")
-	height, _ := cmd.Flags().GetUint64("height")
-	flag, _ := cmd.Flags().GetInt32("flag")
-
-	params := &ty.BtcHeader{
-		Hash:         blockhash,
-		PreviousHash: prehash,
-		MerkleRoot:   merkleroot,
-		Height:       height,
-		IsReset:      flag == 1,
+	payLoad, err := json.Marshal(params)
+	if err != nil {
+		return
 	}
 
-	var res string
-	ctx := jsonclient.NewRPCCtx(rpcLaddr, "relay.CreateRawRelaySaveBTCHeadTx", params, &res)
-	ctx.RunWithoutMarshal()
+	createTx(cmd, payLoad, "ConfirmTx")
 }

plugin/dapp/relay/commands/types.go

@@ -9,7 +9,7 @@ type relayOrder2Show struct {
 	Status        string `json:"status"`
 	Creator       string `json:"address"`
 	Amount        string `json:"amount"`
-	CoinOperation string `json:"coinoperation"`
+	CoinOperation uint32 `json:"coinoperation"`
 	Coin          string `json:"coin"`
 	CoinAmount    string `json:"coinamount"`
 	CoinAddr      string `json:"coinaddr"`
@@ -21,4 +21,6 @@ type relayOrder2Show struct {
 	FinishTime    int64  `json:"finishtime"`
 	FinishTxHash  string `json:"finishtxhash"`
 	Height        int64  `json:"height"`
+	LocalCoinExec string `json:"localCoinExec"`
+	LocalCoinSym  string `json:"localCoinSym"`
 }

plugin/dapp/relay/executor/kv.go

@@ -7,6 +7,8 @@ package executor
 import (
 	"fmt"
 
+	"strings"
+
 	ty "github.com/33cn/plugin/plugin/dapp/relay/types"
 )
 
@@ -46,25 +48,25 @@ func calcBtcHeaderKeyHeightList(height int64) []byte {
 
 func calcOrderKeyStatus(order *ty.RelayOrder, status int32) []byte {
 	key := fmt.Sprintf(relayOrderSCAIH+"%d:%s:%s:%s:%d",
-		status, order.Coin, order.CreaterAddr, order.Id, order.Height)
+		status, order.XCoin, order.CreaterAddr, order.Id, order.Height)
 	return []byte(key)
 }
 
 func calcOrderKeyCoin(order *ty.RelayOrder, status int32) []byte {
 	key := fmt.Sprintf(relayOrderCSAIH+"%s:%d:%s:%s:%d",
-		order.Coin, status, order.CreaterAddr, order.Id, order.Height)
+		order.XCoin, status, order.CreaterAddr, order.Id, order.Height)
 	return []byte(key)
 }
 
 func calcOrderKeyAddrStatus(order *ty.RelayOrder, status int32) []byte {
 	key := fmt.Sprintf(relayOrderASCIH+"%s:%d:%s:%s:%d",
-		order.CreaterAddr, status, order.Coin, order.Id, order.Height)
+		order.CreaterAddr, status, order.XCoin, order.Id, order.Height)
 	return []byte(key)
 }
 
 func calcOrderKeyAddrCoin(order *ty.RelayOrder, status int32) []byte {
 	key := fmt.Sprintf(relayOrderACSIH+"%s:%s:%d:%s:%d",
-		order.CreaterAddr, order.Coin, status, order.Id, order.Height)
+		order.CreaterAddr, order.XCoin, status, order.Id, order.Height)
 	return []byte(key)
 }
 
@@ -90,7 +92,7 @@ func calcOrderPrefixAddr(addr string) []byte {
 func calcAcceptKeyAddr(order *ty.RelayOrder, status int32) []byte {
 	if order.AcceptAddr != "" {
 		return []byte(fmt.Sprintf(relayBuyOrderACSIH+"%s:%s:%d:%s:%d",
-			order.AcceptAddr, order.Coin, status, order.Id, order.Height))
+			order.AcceptAddr, order.XCoin, status, order.Id, order.Height))
 	}
 	return nil
 
@@ -111,3 +113,9 @@ func calcRelayOrderID(hash string) string {
 func calcCoinHash(hash string) string {
 	return coinHashPrefix + hash
 }
+
+func getRealTxHashID(id string) string {
+	ids := strings.Split(id, "-")
+	return ids[len(ids)-1]
+
+}

plugin/dapp/relay/executor/relay.go

@@ -133,6 +133,10 @@ func (r *relay) getRelayOrderReply(OrderIDs [][]byte) (types.Message, error) {
 			orderIDGot[string(orderID)] = true
 		}
 	}
+	//get remove mavl-xx- prefix
+	for _, order := range reply.Relayorders {
+		order.Id = getRealTxHashID(order.Id)
+	}
 	return &reply, nil
 }
 
@@ -142,7 +146,7 @@ func insertOrderDescending(toBeInserted *ty.RelayOrder, orders []*ty.RelayOrder)
 	} else {
 		index := len(orders)
 		for i, element := range orders {
-			if toBeInserted.Amount >= element.Amount {
+			if toBeInserted.LocalCoinAmount >= element.LocalCoinAmount {
 				index = i
 				break
 			}

plugin/dapp/relay/executor/relay_test.go

@@ -124,10 +124,10 @@ func (s *suiteRelay) testExecDelLocal(tx *types.Transaction, receipt *types.Rece
 func (s *suiteRelay) TestExec_1() {
 	order := &ty.RelayCreate{
 		Operation:       ty.RelayOrderSell,
-		Coin:      "BTC",
-		Amount:    0.299 * 1e8,
-		Addr:      addrBtc,
-		BtyAmount: 200 * 1e8,
+		XCoin:           "BTC",
+		XAmount:         0.299 * 1e8,
+		XAddr:           addrBtc,
+		LocalCoinAmount: 200 * 1e8,
 	}
 
 	sell := &ty.RelayAction{
@@ -156,10 +156,10 @@ func (s *suiteRelay) TestExec_1() {
 
 	var log ty.ReceiptRelayLog
 	types.Decode(receipt.Logs[len(receipt.Logs)-1].Log, &log)
-	s.Equal("200.0000", log.TxAmount)
-	s.Equal(uint64(10), log.CoinHeight)
+	s.Equal("200.0000", log.LocalCoinAmount)
+	s.Equal(uint64(10), log.XHeight)
 
-	s.orderID = log.OrderId
+	s.orderID = getRealTxHashID(log.OrderId)
 
 	//s.testExecLocal(tx, receipt)
 	//s.testExecDelLocal(tx, receipt)
@@ -170,7 +170,7 @@ func (s *suiteRelay) TestExec_1() {
 func (s *suiteRelay) TestExec_2() {
 	order := &ty.RelayAccept{
 		OrderId: s.orderID,
-		CoinAddr: addrBtc,
+		XAddr:   addrBtc,
 	}
 
 	sell := &ty.RelayAction{
@@ -197,8 +197,8 @@ func (s *suiteRelay) TestExec_2() {
 
 	var log ty.ReceiptRelayLog
 	types.Decode(receipt.Logs[len(receipt.Logs)-1].Log, &log)
-	s.Equal("200.0000", log.TxAmount)
-	s.Equal(uint64(20), log.CoinHeight)
+	s.Equal("200.0000", log.LocalCoinAmount)
+	s.Equal(uint64(20), log.XHeight)
 	s.Equal(ty.RelayOrderStatus_locking.String(), log.CurStatus)
 
 }
@@ -233,8 +233,8 @@ func (s *suiteRelay) TestExec_3() {
 
 	var log ty.ReceiptRelayLog
 	types.Decode(receipt.Logs[len(receipt.Logs)-1].Log, &log)
-	s.Equal("200.0000", log.TxAmount)
-	s.Equal(uint64(30), log.CoinHeight)
+	s.Equal("200.0000", log.LocalCoinAmount)
+	s.Equal(uint64(30), log.XHeight)
 	s.Equal(ty.RelayOrderStatus_confirming.String(), log.CurStatus)
 
 }
@@ -319,45 +319,15 @@ func (s *suiteRelay) TestExec_9_QryStatus1() {
 	}
 
 	var OrderIds [][]byte
-	OrderIds = append(OrderIds, []byte(s.orderID))
+	OrderIds = append(OrderIds, []byte(calcRelayOrderID(s.orderID)))
 	s.kvdb.On("List", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(OrderIds, nil).Once()
 	msg, err := s.relay.Query_GetRelayOrderByStatus(addrCoins)
 	s.Nil(err)
-	//s.T().Log(msg.String())
+	s.T().Log(msg.String())
 	s.Contains(msg.String(), "status:finished")
 	//s.Equal(ty.RelayOrderStatus_finished,)
 }
 
-func (s *suiteRelay) TestExec_9_QryStatus2() {
-	addrCoins := &ty.ReqRelayAddrCoins{
-		Addr: addrFrom,
-		//Status: ty.RelayOrderStatus_finished,
-		Coins: []string{"BTC"},
-	}
-
-	var OrderIds [][]byte
-	OrderIds = append(OrderIds, []byte(s.orderID))
-	s.kvdb.On("List", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(OrderIds, nil).Once()
-	msg, err := s.relay.Query_GetSellRelayOrder(addrCoins)
-	s.Nil(err)
-	s.Contains(msg.String(), "status:finished")
-}
-
-func (s *suiteRelay) TestExec_9_QryStatus3() {
-	addrCoins := &ty.ReqRelayAddrCoins{
-		Addr: addrTo,
-		//Status: ty.RelayOrderStatus_finished,
-		Coins: []string{"BTC"},
-	}
-
-	var OrderIds [][]byte
-	OrderIds = append(OrderIds, []byte(s.orderID))
-	s.kvdb.On("List", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(OrderIds, nil).Once()
-	msg, err := s.relay.Query_GetBuyRelayOrder(addrCoins)
-	s.Nil(err)
-	s.Contains(msg.String(), "status:finished")
-}
-
 func (s *suiteRelay) TestExec_9_QryStatus4() {
 	addrCoins := &ty.ReqRelayBtcHeaderHeightList{
 		ReqHeight: 12,

plugin/dapp/relay/executor/relaybtc.go

@@ -197,7 +197,7 @@ func (b *btcStore) getMerkleRootFromHeader(blockhash string) (string, error) {
 func (b *btcStore) verifyBtcTx(verify *ty.RelayVerify, order *ty.RelayOrder) error {
 	var foundtx bool
 	for _, outtx := range verify.GetTx().GetVout() {
-		if outtx.Address == order.CoinAddr && outtx.Value >= order.CoinAmount {
+		if outtx.Address == order.XAddr && outtx.Value >= order.XAmount {
 			foundtx = true
 		}
 	}
@@ -220,7 +220,7 @@ func (b *btcStore) verifyBtcTx(verify *ty.RelayVerify, order *ty.RelayOrder) err
 		return err
 	}
 
-	if verify.Tx.BlockHeight+uint64(order.CoinWaits) > uint64(height) {
+	if verify.Tx.BlockHeight+uint64(order.XBlockWaits) > uint64(height) {
 		return ty.ErrRelayWaitBlocksErr
 	}
 

plugin/dapp/relay/executor/relaybtc_test.go

@@ -197,8 +197,8 @@ func (s *suiteBtcStore) TestGetMerkleRootFromHeader() {
 
 func (s *suiteBtcStore) TestVerifyBtcTx() {
 	order := &ty.RelayOrder{
-		CoinAddr:    "1Am9UTGfdnxabvcywYG2hvzr6qK8T3oUZT",
-		CoinAmount:  29900000,
+		XAddr:       "1Am9UTGfdnxabvcywYG2hvzr6qK8T3oUZT",
+		XAmount:     29900000,
 		AcceptTime:  100,
 		ConfirmTime: 200,
 	}

plugin/dapp/relay/executor/relaydb.go

@@ -16,6 +16,8 @@ import (
 	"github.com/33cn/chain33/system/dapp"
 	"github.com/33cn/chain33/types"
 	ty "github.com/33cn/plugin/plugin/dapp/relay/types"
+	token "github.com/33cn/plugin/plugin/dapp/token/types"
+	"github.com/pkg/errors"
 )
 
 const (
@@ -46,8 +48,8 @@ func (r *relayLog) getKVSet() (kvSet []*types.KeyValue) {
 	key := []byte(r.Id)
 	kvSet = append(kvSet, &types.KeyValue{Key: key, Value: value})
 
-	if r.CoinTxHash != "" {
-		key = []byte(calcCoinHash(r.CoinTxHash))
+	if r.XTxHash != "" {
+		key = []byte(calcCoinHash(r.XTxHash))
 		kvSet = append(kvSet, &types.KeyValue{Key: key, Value: value})
 	}
 
@@ -62,19 +64,21 @@ func (r *relayLog) receiptLog(relayLogType int32) *types.ReceiptLog {
 		CurStatus:       r.Status.String(),
 		PreStatus:       r.PreStatus.String(),
 		CreaterAddr:     r.CreaterAddr,
-		TxAmount:      strconv.FormatFloat(float64(r.Amount)/float64(types.Coin), 'f', 4, 64),
-		CoinOperation: ty.RelayOrderOperation[r.CoinOperation],
-		Coin:          r.Coin,
-		CoinAmount:    strconv.FormatFloat(float64(r.CoinAmount)/float64(types.Coin), 'f', 4, 64),
-		CoinAddr:      r.CoinAddr,
-		CoinTxHash:    r.CoinTxHash,
-		CoinWaits:     r.CoinWaits,
+		LocalCoinAmount: strconv.FormatFloat(float64(r.LocalCoinAmount)/float64(types.Coin), 'f', 4, 64),
+		CoinOperation:   r.Operation,
+		XCoin:           r.XCoin,
+		XAmount:         strconv.FormatFloat(float64(r.XAmount)/float64(types.Coin), 'f', 4, 64),
+		XAddr:           r.XAddr,
+		XTxHash:         r.XTxHash,
+		XBlockWaits:     r.XBlockWaits,
 		CreateTime:      r.CreateTime,
 		AcceptAddr:      r.AcceptAddr,
 		AcceptTime:      r.AcceptTime,
 		ConfirmTime:     r.ConfirmTime,
 		FinishTime:      r.FinishTime,
-		CoinHeight:    r.CoinHeight,
+		XHeight:         r.XHeight,
+		LocalCoinExec:   r.LocalCoinExec,
+		LocalCoinSymbol: r.LocalCoinSymbol,
 	}
 
 	log.Log = types.Encode(receipt)
@@ -102,8 +106,8 @@ func newRelayDB(r *relay, tx *types.Transaction) *relayDB {
 		fromAddr, r.GetBlockTime(), r.GetHeight(), dapp.ExecAddress(string(tx.Execer)), btc, r.GetAPI()}
 }
 
-func (action *relayDB) getOrderByID(orderID []byte) (*ty.RelayOrder, error) {
-	value, err := action.db.Get(orderID)
+func (action *relayDB) getOrderByID(orderID string) (*ty.RelayOrder, error) {
+	value, err := action.db.Get([]byte(calcRelayOrderID(orderID)))
 	if err != nil {
 		return nil, err
 	}
@@ -128,22 +132,39 @@ func (action *relayDB) getOrderByCoinHash(hash []byte) (*ty.RelayOrder, error) {
 	return &order, nil
 }
 
+func (action *relayDB) createAccount(exec, symbol string) (*account.DB, error) {
+	var accDB *account.DB
+	cfg := action.api.GetConfig()
+
+	if symbol == "" {
+		accDB = account.NewCoinsAccount(cfg)
+		accDB.SetDB(action.db)
+		return accDB, nil
+	}
+	if exec == "" {
+		exec = token.TokenX
+	}
+	return account.NewAccountDB(cfg, exec, symbol, action.db)
+}
+
 func (action *relayDB) create(order *ty.RelayCreate) (*types.Receipt, error) {
 	var receipt *types.Receipt
 	var err error
-	var coinAddr string
-	var coinWaits uint32
+
+	accDb, err := action.createAccount(order.LocalCoinExec, order.LocalCoinSymbol)
+	if err != nil {
+		return nil, errors.Wrapf(err, "relay create,exec=%s,sym=%s", order.LocalCoinExec, order.LocalCoinSymbol)
+	}
+
 	if order.Operation == ty.RelayOrderBuy {
-		receipt, err = action.coinsAccount.ExecFrozen(action.fromAddr, action.execAddr, int64(order.BtyAmount))
+		receipt, err = accDb.ExecFrozen(action.fromAddr, action.execAddr, int64(order.LocalCoinAmount))
 		if err != nil {
-			relaylog.Error("account.ExecFrozen relay ", "addrFrom", action.fromAddr, "execAddr", action.execAddr, "amount", order.BtyAmount)
+			relaylog.Error("account.ExecFrozen relay ", "addrFrom", action.fromAddr, "execAddr", action.execAddr, "amount", order.LocalCoinAmount)
 			return nil, err
 		}
 
-		coinAddr = order.Addr
-		coinWaits = order.CoinWaits
 	} else {
-		receipt, err = action.coinsAccount.ExecFrozen(action.fromAddr, action.execAddr, int64(lockBtyAmount))
+		receipt, err = accDb.ExecFrozen(action.fromAddr, action.execAddr, int64(lockBtyAmount))
 		if err != nil {
 			relaylog.Error("account.ExecFrozen relay ", "addrFrom", action.fromAddr, "execAddr", action.execAddr, "amount", lockBtyAmount)
 			return nil, err
@@ -156,22 +177,24 @@ func (action *relayDB) create(order *ty.RelayCreate) (*types.Receipt, error) {
 		Id:              calcRelayOrderID(common.ToHex(action.txHash)),
 		Status:          ty.RelayOrderStatus_pending,
 		PreStatus:       ty.RelayOrderStatus_init,
-		Amount:        order.BtyAmount,
+		Operation:       order.Operation,
+		LocalCoinAmount: order.LocalCoinAmount,
 		CreaterAddr:     action.fromAddr,
-		CoinOperation: order.Operation,
-		Coin:          order.Coin,
-		CoinAmount:    order.Amount,
-		CoinAddr:      coinAddr,
-		CoinWaits:     coinWaits,
+		XCoin:           order.XCoin,
+		XAmount:         order.XAmount,
+		XAddr:           order.XAddr,
+		XBlockWaits:     order.XBlockWaits,
 		CreateTime:      action.blockTime,
 		Height:          action.height,
+		LocalCoinExec:   order.LocalCoinExec,
+		LocalCoinSymbol: order.LocalCoinSymbol,
 	}
 
 	height, err := action.btc.getLastBtcHeadHeight()
 	if err != nil {
 		return nil, err
 	}
-	uOrder.CoinHeight = uint64(height)
+	uOrder.XHeight = uint64(height)
 
 	logs = append(logs, receipt.Logs...)
 	kv = append(kv, receipt.KV...)
@@ -193,8 +216,8 @@ func (action *relayDB) checkRevokeOrder(order *ty.RelayOrder) error {
 		return err
 	}
 
-	if nowBtcHeight > 0 && order.CoinHeight > 0 && nowBtcHeight > int64(order.CoinHeight) {
-		subHeight = nowBtcHeight - int64(order.CoinHeight)
+	if nowBtcHeight > 0 && order.XHeight > 0 && nowBtcHeight > int64(order.XHeight) {
+		subHeight = nowBtcHeight - int64(order.XHeight)
 	}
 
 	if order.Status == ty.RelayOrderStatus_locking {
@@ -218,8 +241,7 @@ func (action *relayDB) checkRevokeOrder(order *ty.RelayOrder) error {
 }
 
 func (action *relayDB) revokeCreate(revoke *ty.RelayRevoke) (*types.Receipt, error) {
-	orderID := []byte(revoke.OrderId)
-	order, err := action.getOrderByID(orderID)
+	order, err := action.getOrderByID(revoke.OrderId)
 	if err != nil {
 		return nil, ty.ErrRelayOrderNotExist
 	}
@@ -248,22 +270,27 @@ func (action *relayDB) revokeCreate(revoke *ty.RelayRevoke) (*types.Receipt, err
 		return nil, ty.ErrRelayReturnAddr
 	}
 
+	accDb, err := action.createAccount(order.LocalCoinExec, order.LocalCoinSymbol)
+	if err != nil {
+		return nil, errors.Wrapf(err, "relay revokeCreate,exec=%s,sym=%s", order.LocalCoinExec, order.LocalCoinSymbol)
+	}
+
 	var receipt *types.Receipt
 	var receiptTransfer *types.Receipt
-	if order.CoinOperation == ty.RelayOrderBuy {
-		receipt, err = action.coinsAccount.ExecActive(order.CreaterAddr, action.execAddr, int64(order.Amount))
+	if order.Operation == ty.RelayOrderBuy {
+		receipt, err = accDb.ExecActive(order.CreaterAddr, action.execAddr, int64(order.LocalCoinAmount))
 		if err != nil {
-			relaylog.Error("revoke create", "addrFrom", order.CreaterAddr, "execAddr", action.execAddr, "amount", order.Amount)
+			relaylog.Error("revoke create", "addrFrom", order.CreaterAddr, "execAddr", action.execAddr, "amount", order.LocalCoinAmount)
 			return nil, err
 		}
 	} else if order.Status != ty.RelayOrderStatus_pending {
-		receipt, err = action.coinsAccount.ExecActive(order.AcceptAddr, action.execAddr, int64(order.Amount))
+		receipt, err = accDb.ExecActive(order.AcceptAddr, action.execAddr, int64(order.LocalCoinAmount))
 		if err != nil {
-			relaylog.Error("revoke create", "addrFrom", order.AcceptAddr, "execAddr", action.execAddr, "amount", order.Amount)
+			relaylog.Error("revoke create", "addrFrom", order.AcceptAddr, "execAddr", action.execAddr, "amount", order.LocalCoinAmount)
 			return nil, err
 		}
 
-		receiptTransfer, err = action.coinsAccount.ExecTransferFrozen(order.CreaterAddr, order.AcceptAddr, action.execAddr, int64(lockBtyAmount))
+		receiptTransfer, err = accDb.ExecTransferFrozen(order.CreaterAddr, order.AcceptAddr, action.execAddr, int64(lockBtyAmount))
 		if err != nil {
 			relaylog.Error("revokeAccept", "from", order.AcceptAddr, "to", order.CreaterAddr, "execAddr", action.execAddr, "amount", lockBtyAmount)
 			return nil, err
@@ -296,8 +323,7 @@ func (action *relayDB) revokeCreate(revoke *ty.RelayRevoke) (*types.Receipt, err
 }
 
 func (action *relayDB) accept(accept *ty.RelayAccept) (*types.Receipt, error) {
-	orderID := []byte(accept.OrderId)
-	order, err := action.getOrderByID(orderID)
+	order, err := action.getOrderByID(accept.OrderId)
 	if err != nil {
 		return nil, ty.ErrRelayOrderNotExist
 	}
@@ -309,27 +335,31 @@ func (action *relayDB) accept(accept *ty.RelayAccept) (*types.Receipt, error) {
 		return nil, ty.ErrRelayOrderSoldout
 	}
 
-	var receipt *types.Receipt
+	accDb, err := action.createAccount(order.LocalCoinExec, order.LocalCoinSymbol)
+	if err != nil {
+		return nil, errors.Wrapf(err, "relay accept,exec=%s,sym=%s", order.LocalCoinExec, order.LocalCoinSymbol)
+	}
 
-	if order.CoinOperation == ty.RelayOrderBuy {
-		receipt, err = action.coinsAccount.ExecFrozen(action.fromAddr, action.execAddr, int64(lockBtyAmount))
+	var receipt *types.Receipt
+	if order.Operation == ty.RelayOrderBuy {
+		receipt, err = accDb.ExecFrozen(action.fromAddr, action.execAddr, int64(lockBtyAmount))
 		if err != nil {
 			relaylog.Error("relay accept frozen fail ", "addrFrom", action.fromAddr, "execAddr", action.execAddr, "amount", lockBtyAmount)
 			return nil, err
 		}
 
 	} else {
-		if accept.CoinAddr == "" {
+		if accept.XAddr == "" {
 			relaylog.Error("accept, for sell operation, coinAddr needed")
 			return nil, ty.ErrRelayOrderParamErr
 		}
 
-		order.CoinAddr = accept.CoinAddr
-		order.CoinWaits = accept.CoinWaits
+		order.XAddr = accept.XAddr
+		order.XBlockWaits = accept.XBlockWaits
 
-		receipt, err = action.coinsAccount.ExecFrozen(action.fromAddr, action.execAddr, int64(order.Amount))
+		receipt, err = accDb.ExecFrozen(action.fromAddr, action.execAddr, int64(order.LocalCoinAmount))
 		if err != nil {
-			relaylog.Error("relay accept frozen fail", "addrFrom", action.fromAddr, "execAddr", action.execAddr, "amount", order.Amount)
+			relaylog.Error("relay accept frozen fail", "addrFrom", action.fromAddr, "execAddr", action.execAddr, "amount", order.LocalCoinAmount)
 			return nil, err
 		}
 	}
@@ -343,7 +373,7 @@ func (action *relayDB) accept(accept *ty.RelayAccept) (*types.Receipt, error) {
 	if err != nil {
 		return nil, err
 	}
-	order.CoinHeight = uint64(height)
+	order.XHeight = uint64(height)
 
 	var logs []*types.ReceiptLog
 	var kv []*types.KeyValue
@@ -370,8 +400,7 @@ func (action *relayDB) relayRevoke(revoke *ty.RelayRevoke) (*types.Receipt, erro
 }
 
 func (action *relayDB) revokeAccept(revoke *ty.RelayRevoke) (*types.Receipt, error) {
-	orderIDByte := []byte(revoke.OrderId)
-	order, err := action.getOrderByID(orderIDByte)
+	order, err := action.getOrderByID(revoke.OrderId)
 	if err != nil {
 		return nil, ty.ErrRelayOrderNotExist
 	}
@@ -392,19 +421,24 @@ func (action *relayDB) revokeAccept(revoke *ty.RelayRevoke) (*types.Receipt, err
 		return nil, ty.ErrRelayReturnAddr
 	}
 
+	accDb, err := action.createAccount(order.LocalCoinExec, order.LocalCoinSymbol)
+	if err != nil {
+		return nil, errors.Wrapf(err, "relay revokeAccept,exec=%s,sym=%s", order.LocalCoinExec, order.LocalCoinSymbol)
+	}
+
 	var receipt *types.Receipt
-	if order.CoinOperation == ty.RelayOrderSell {
-		receipt, err = action.coinsAccount.ExecActive(order.AcceptAddr, action.execAddr, int64(order.Amount))
+	if order.Operation == ty.RelayOrderSell {
+		receipt, err = accDb.ExecActive(order.AcceptAddr, action.execAddr, int64(order.LocalCoinAmount))
 		if err != nil {
-			relaylog.Error("revokeAccept", "addrFrom", order.AcceptAddr, "execAddr", action.execAddr, "amount", order.Amount)
+			relaylog.Error("revokeAccept", "addrFrom", order.AcceptAddr, "execAddr", action.execAddr, "amount", order.LocalCoinAmount)
 			return nil, err
 		}
-		order.CoinAddr = ""
+		order.XAddr = ""
 	}
 
 	var receiptTransfer *types.Receipt
-	if order.CoinOperation == ty.RelayOrderBuy {
-		receiptTransfer, err = action.coinsAccount.ExecTransferFrozen(order.AcceptAddr, order.CreaterAddr, action.execAddr, int64(lockBtyAmount))
+	if order.Operation == ty.RelayOrderBuy {
+		receiptTransfer, err = accDb.ExecTransferFrozen(order.AcceptAddr, order.CreaterAddr, action.execAddr, int64(lockBtyAmount))
 		if err != nil {
 			relaylog.Error("revokeAccept", "from", order.AcceptAddr, "to", order.CreaterAddr, "execAddr", action.execAddr, "amount", lockBtyAmount)
 			return nil, err
@@ -435,8 +469,7 @@ func (action *relayDB) revokeAccept(revoke *ty.RelayRevoke) (*types.Receipt, err
 }
 
 func (action *relayDB) confirmTx(confirm *ty.RelayConfirmTx) (*types.Receipt, error) {
-	orderID := []byte(confirm.OrderId)
-	order, err := action.getOrderByID(orderID)
+	order, err := action.getOrderByID(confirm.OrderId)
 	if err != nil {
 		return nil, ty.ErrRelayOrderNotExist
 	}
@@ -461,7 +494,7 @@ func (action *relayDB) confirmTx(confirm *ty.RelayConfirmTx) (*types.Receipt, er
 	}
 
 	var confirmAddr string
-	if order.CoinOperation == ty.RelayOrderBuy {
+	if order.Operation == ty.RelayOrderBuy {
 		confirmAddr = order.AcceptAddr
 	} else {
 		confirmAddr = order.CreaterAddr
@@ -473,13 +506,13 @@ func (action *relayDB) confirmTx(confirm *ty.RelayConfirmTx) (*types.Receipt, er
 	order.PreStatus = order.Status
 	order.Status = ty.RelayOrderStatus_confirming
 	order.ConfirmTime = action.blockTime
-	order.CoinTxHash = confirm.TxHash
+	order.XTxHash = confirm.TxHash
 	height, err := action.btc.getLastBtcHeadHeight()
 	if err != nil {
 		relaylog.Error("confirmTx Get Last BTC", "orderid", confirm.OrderId)
 		return nil, err
 	}
-	order.CoinHeight = uint64(height)
+	order.XHeight = uint64(height)
 
 	var logs []*types.ReceiptLog
 	var kv []*types.KeyValue
@@ -495,8 +528,7 @@ func (action *relayDB) confirmTx(confirm *ty.RelayConfirmTx) (*types.Receipt, er
 }
 
 func (action *relayDB) verifyTx(verify *ty.RelayVerify) (*types.Receipt, error) {
-	orderID := []byte(verify.OrderId)
-	order, err := action.getOrderByID(orderID)
+	order, err := action.getOrderByID(verify.OrderId)
 	if err != nil {
 		return nil, ty.ErrRelayOrderNotExist
 	}
@@ -516,16 +548,21 @@ func (action *relayDB) verifyTx(verify *ty.RelayVerify) (*types.Receipt, error)
 		return nil, err
 	}
 
+	accDb, err := action.createAccount(order.LocalCoinExec, order.LocalCoinSymbol)
+	if err != nil {
+		return nil, errors.Wrapf(err, "relay revokeAccept,exec=%s,sym=%s", order.LocalCoinExec, order.LocalCoinSymbol)
+	}
+
 	var receipt *types.Receipt
-	if order.CoinOperation == ty.RelayOrderBuy {
-		receipt, err = action.coinsAccount.ExecTransferFrozen(order.CreaterAddr, order.AcceptAddr, action.execAddr, int64(order.Amount))
+	if order.Operation == ty.RelayOrderBuy {
+		receipt, err = accDb.ExecTransferFrozen(order.CreaterAddr, order.AcceptAddr, action.execAddr, int64(order.LocalCoinAmount))
 		if err != nil {
 			relaylog.Error("verify buy transfer fail", "error", err.Error())
 			return nil, err
 		}
 
 	} else {
-		receipt, err = action.coinsAccount.ExecTransferFrozen(order.AcceptAddr, order.CreaterAddr, action.execAddr, int64(order.Amount))
+		receipt, err = accDb.ExecTransferFrozen(order.AcceptAddr, order.CreaterAddr, action.execAddr, int64(order.LocalCoinAmount))
 		if err != nil {
 			relaylog.Error("verify sell transfer fail", "error", err.Error())
 			return nil, err
@@ -533,15 +570,15 @@ func (action *relayDB) verifyTx(verify *ty.RelayVerify) (*types.Receipt, error)
 	}
 
 	var receiptTransfer *types.Receipt
-	if order.CoinOperation == ty.RelayOrderBuy {
-		receiptTransfer, err = action.coinsAccount.ExecActive(order.AcceptAddr, action.execAddr, int64(lockBtyAmount))
+	if order.Operation == ty.RelayOrderBuy {
+		receiptTransfer, err = accDb.ExecActive(order.AcceptAddr, action.execAddr, int64(lockBtyAmount))
 		if err != nil {
 			relaylog.Error("verify exec active", "from", order.AcceptAddr, "amount", lockBtyAmount)
 			return nil, err
 		}
 
 	} else {
-		receiptTransfer, err = action.coinsAccount.ExecActive(order.CreaterAddr, action.execAddr, int64(lockBtyAmount))
+		receiptTransfer, err = accDb.ExecActive(order.CreaterAddr, action.execAddr, int64(lockBtyAmount))
 		if err != nil {
 			relaylog.Error("verify exec active", "from", order.CreaterAddr, "amount", lockBtyAmount)
 			return nil, err
@@ -568,82 +605,6 @@ func (action *relayDB) verifyTx(verify *ty.RelayVerify) (*types.Receipt, error)
 
 }
 
-//之前用作cli verify, 检查不严格，现在弃用
-func (action *relayDB) verifyCmdTx(verify *ty.RelayVerifyCli) (*types.Receipt, error) {
-	orderID := []byte(verify.OrderId)
-	order, err := action.getOrderByID(orderID)
-	if err != nil {
-		return nil, ty.ErrRelayOrderNotExist
-	}
-
-	if order.Status == ty.RelayOrderStatus_finished {
-		return nil, ty.ErrRelayOrderSoldout
-	}
-	if order.Status == ty.RelayOrderStatus_canceled {
-		return nil, ty.ErrRelayOrderRevoked
-	}
-	if order.Status == ty.RelayOrderStatus_pending || order.Status == ty.RelayOrderStatus_locking {
-		return nil, ty.ErrRelayOrderOnSell
-	}
-
-	var receipt *types.Receipt
-
-	err = action.btc.verifyCmdBtcTx(verify)
-	if err != nil {
-		return nil, err
-	}
-
-	if order.CoinOperation == ty.RelayOrderBuy {
-		receipt, err = action.coinsAccount.ExecTransferFrozen(order.CreaterAddr, order.AcceptAddr, action.execAddr, int64(order.Amount))
-
-	} else {
-		receipt, err = action.coinsAccount.ExecTransferFrozen(order.AcceptAddr, order.CreaterAddr, action.execAddr, int64(order.Amount))
-	}
-
-	if err != nil {
-		relaylog.Error("relay verify tx transfer fail", "error", err.Error())
-		return nil, err
-	}
-
-	var receiptTransfer *types.Receipt
-	if order.CoinOperation == ty.RelayOrderBuy {
-		receiptTransfer, err = action.coinsAccount.ExecActive(order.AcceptAddr, action.execAddr, int64(lockBtyAmount))
-		if err != nil {
-			relaylog.Error("verify exec active", "from", order.AcceptAddr, "amount", lockBtyAmount)
-			return nil, err
-		}
-
-	} else {
-		receiptTransfer, err = action.coinsAccount.ExecActive(order.CreaterAddr, action.execAddr, int64(lockBtyAmount))
-		if err != nil {
-			relaylog.Error("verify exec active", "from", order.CreaterAddr, "amount", lockBtyAmount)
-			return nil, err
-		}
-	}
-
-	order.PreStatus = order.Status
-	order.Status = ty.RelayOrderStatus_finished
-	order.FinishTime = action.blockTime
-
-	relayLog := newRelayLog(order)
-	orderKV := relayLog.save(action.db)
-
-	if err != nil {
-		return nil, err
-	}
-
-	var logs []*types.ReceiptLog
-	var kv []*types.KeyValue
-	logs = append(logs, receipt.Logs...)
-	logs = append(logs, receiptTransfer.Logs...)
-	logs = append(logs, relayLog.receiptLog(ty.TyLogRelayFinishTx))
-	kv = append(kv, receipt.KV...)
-	kv = append(kv, receiptTransfer.KV...)
-	kv = append(kv, orderKV...)
-	return &types.Receipt{Ty: types.ExecOk, KV: kv, Logs: logs}, nil
-
-}
-
 func saveBtcLastHead(db dbm.KV, head *ty.RelayLastRcvBtcHeader) (set []*types.KeyValue) {
 	if head == nil || head.Header == nil {
 		return nil

plugin/dapp/relay/executor/relaydb_test.go

@@ -35,7 +35,7 @@ func TestRunSuiteRelayLog(t *testing.T) {
 func (s *suiteRelayLog) SetupSuite() {
 	order := &ty.RelayOrder{
 		Id:      "123456",
-		CoinTxHash: "aabbccddee",
+		XTxHash: "aabbccddee",
 	}
 	s.db = new(mocks.KV)
 
@@ -46,7 +46,7 @@ func (s *suiteRelayLog) TestSave() {
 	kvSet := []*types.KeyValue{}
 	value := types.Encode(&s.log.RelayOrder)
 	keyID := []byte(s.log.Id)
-	keyCoinTxHash := []byte(calcCoinHash(s.log.CoinTxHash))
+	keyCoinTxHash := []byte(calcCoinHash(s.log.XTxHash))
 	kvSet = append(kvSet, &types.KeyValue{Key: keyID, Value: value})
 	kvSet = append(kvSet, &types.KeyValue{Key: keyCoinTxHash, Value: value})
 
@@ -62,7 +62,7 @@ func (s *suiteRelayLog) TestGetKVSet() {
 	kvSet := []*types.KeyValue{}
 	value := types.Encode(&s.log.RelayOrder)
 	keyID := []byte(s.log.Id)
-	keyCoinTxHash := []byte(calcCoinHash(s.log.CoinTxHash))
+	keyCoinTxHash := []byte(calcCoinHash(s.log.XTxHash))
 	kvSet = append(kvSet, &types.KeyValue{Key: keyID, Value: value})
 	kvSet = append(kvSet, &types.KeyValue{Key: keyCoinTxHash, Value: value})
 
@@ -167,10 +167,10 @@ func (s *suiteRelayDB) SetupSuite() {
 func (s *suiteRelayDB) TestRelayCreate_1() {
 	order := &ty.RelayCreate{
 		Operation:       ty.RelayOrderBuy,
-		Coin:      "BTC",
-		Amount:    10 * 1e8,
-		Addr:      addrBtc,
-		BtyAmount: 200 * 1e8,
+		XCoin:           "BTC",
+		XAmount:         10 * 1e8,
+		XAddr:           addrBtc,
+		LocalCoinAmount: 200 * 1e8,
 	}
 
 	tx := &types.Transaction{}
@@ -193,9 +193,9 @@ func (s *suiteRelayDB) TestRelayCreate_1() {
 
 	var log ty.ReceiptRelayLog
 	types.Decode(receipt.Logs[len(receipt.Logs)-1].Log, &log)
-	s.Equal("200.0000", log.TxAmount)
-	s.Equal(uint64(10), log.CoinHeight)
-	s.orderID = log.OrderId
+	s.Equal("200.0000", log.LocalCoinAmount)
+	s.Equal(uint64(10), log.XHeight)
+	s.orderID = getRealTxHashID(log.OrderId)
 }
 
 // the test suite function name need sequence so here aUnlock, bCancel
@@ -303,10 +303,10 @@ func (s *suiteAccept) setupAccount() {
 func (s *suiteAccept) setupRelayCreate() {
 	order := &ty.RelayCreate{
 		Operation:       ty.RelayOrderBuy,
-		Coin:      "BTC",
-		Amount:    10 * 1e8,
-		Addr:      addrBtc,
-		BtyAmount: 200 * 1e8,
+		XCoin:           "BTC",
+		XAmount:         10 * 1e8,
+		XAddr:           addrBtc,
+		LocalCoinAmount: 200 * 1e8,
 	}
 
 	tx := &types.Transaction{}
@@ -329,10 +329,10 @@ func (s *suiteAccept) setupRelayCreate() {
 
 	var log ty.ReceiptRelayLog
 	types.Decode(receipt.Logs[len(receipt.Logs)-1].Log, &log)
-	s.Equal("200.0000", log.TxAmount)
-	s.Equal(uint64(10), log.CoinHeight)
+	s.Equal("200.0000", log.LocalCoinAmount)
+	s.Equal(uint64(10), log.XHeight)
 
-	s.orderID = log.OrderId
+	s.orderID = getRealTxHashID(log.OrderId)
 }
 
 func (s *suiteAccept) SetupSuite() {
@@ -358,7 +358,7 @@ func (s *suiteAccept) TestRelayAccept() {
 
 	order := &ty.RelayAccept{
 		OrderId: s.orderID,
-		CoinAddr: "BTC",
+		XAddr:   "BTC",
 	}
 
 	tx := &types.Transaction{}
@@ -380,8 +380,8 @@ func (s *suiteAccept) TestRelayAccept() {
 
 	var log ty.ReceiptRelayLog
 	types.Decode(receipt.Logs[len(receipt.Logs)-1].Log, &log)
-	s.Equal("200.0000", log.TxAmount)
-	s.Equal(uint64(20), log.CoinHeight)
+	s.Equal("200.0000", log.LocalCoinAmount)
+	s.Equal(uint64(20), log.XHeight)
 	s.Equal(ty.RelayOrderStatus_locking.String(), log.CurStatus)
 
 }
@@ -452,7 +452,7 @@ func (s *suiteAccept) TestRevokeAccept_3() {
 
 	var log ty.ReceiptRelayLog
 	types.Decode(receipt.Logs[len(receipt.Logs)-1].Log, &log)
-	s.Equal(uint64(20), log.CoinHeight)
+	s.Equal(uint64(20), log.XHeight)
 	s.Equal(ty.RelayOrderStatus_pending.String(), log.CurStatus)
 }
 
@@ -508,10 +508,10 @@ func (s *suiteConfirm) setupAccount() {
 func (s *suiteConfirm) setupRelayCreate() {
 	order := &ty.RelayCreate{
 		Operation:       ty.RelayOrderBuy,
-		Coin:      "BTC",
-		Amount:    10 * 1e8,
-		Addr:      addrBtc,
-		BtyAmount: 200 * 1e8,
+		XCoin:           "BTC",
+		XAmount:         10 * 1e8,
+		XAddr:           addrBtc,
+		LocalCoinAmount: 200 * 1e8,
 	}
 
 	tx := &types.Transaction{}
@@ -534,10 +534,10 @@ func (s *suiteConfirm) setupRelayCreate() {
 
 	var log ty.ReceiptRelayLog
 	types.Decode(receipt.Logs[len(receipt.Logs)-1].Log, &log)
-	s.Equal("200.0000", log.TxAmount)
-	s.Equal(uint64(10), log.CoinHeight)
+	s.Equal("200.0000", log.LocalCoinAmount)
+	s.Equal(uint64(10), log.XHeight)
 
-	s.orderID = log.OrderId
+	s.orderID = getRealTxHashID(log.OrderId)
 }
 
 func (s *suiteConfirm) SetupSuite() {
@@ -564,7 +564,7 @@ func (s *suiteConfirm) setupAccept() {
 
 	order := &ty.RelayAccept{
 		OrderId: s.orderID,
-		CoinAddr: "BTC",
+		XAddr:   "BTC",
 	}
 
 	tx := &types.Transaction{}
@@ -586,8 +586,8 @@ func (s *suiteConfirm) setupAccept() {
 
 	var log ty.ReceiptRelayLog
 	types.Decode(receipt.Logs[len(receipt.Logs)-1].Log, &log)
-	s.Equal("200.0000", log.TxAmount)
-	s.Equal(uint64(20), log.CoinHeight)
+	s.Equal("200.0000", log.LocalCoinAmount)
+	s.Equal(uint64(20), log.XHeight)
 	s.Equal(ty.RelayOrderStatus_locking.String(), log.CurStatus)
 
 }
@@ -637,8 +637,8 @@ func (s *suiteConfirm) TestConfirm_2() {
 
 	var log ty.ReceiptRelayLog
 	types.Decode(receipt.Logs[len(receipt.Logs)-1].Log, &log)
-	s.Equal("200.0000", log.TxAmount)
-	s.Equal(uint64(30), log.CoinHeight)
+	s.Equal("200.0000", log.LocalCoinAmount)
+	s.Equal(uint64(30), log.XHeight)
 	s.Equal(ty.RelayOrderStatus_confirming.String(), log.CurStatus)
 
 }
@@ -686,7 +686,7 @@ func (s *suiteConfirm) TestRevokeConfirm_2() {
 	s.Nil(err)
 	var log ty.ReceiptRelayLog
 	types.Decode(receipt.Logs[len(receipt.Logs)-1].Log, &log)
-	s.Equal(uint64(30), log.CoinHeight)
+	s.Equal(uint64(30), log.XHeight)
 	s.Equal(ty.RelayOrderStatus_pending.String(), log.CurStatus)
 
 }
@@ -743,10 +743,10 @@ func (s *suiteVerify) setupAccount() {
 func (s *suiteVerify) setupRelayCreate() {
 	order := &ty.RelayCreate{
 		Operation:       ty.RelayOrderBuy,
-		Coin:      "BTC",
-		Amount:    0.299 * 1e8,
-		Addr:      addrBtc,
-		BtyAmount: 200 * 1e8,
+		XCoin:           "BTC",
+		XAmount:         0.299 * 1e8,
+		XAddr:           addrBtc,
+		LocalCoinAmount: 200 * 1e8,
 	}
 
 	tx := &types.Transaction{}
@@ -769,17 +769,17 @@ func (s *suiteVerify) setupRelayCreate() {
 
 	var log ty.ReceiptRelayLog
 	types.Decode(receipt.Logs[len(receipt.Logs)-1].Log, &log)
-	s.Equal("200.0000", log.TxAmount)
-	s.Equal(uint64(10), log.CoinHeight)
+	s.Equal("200.0000", log.LocalCoinAmount)
+	s.Equal(uint64(10), log.XHeight)
 
-	s.orderID = log.OrderId
+	s.orderID = getRealTxHashID(log.OrderId)
 }
 
 func (s *suiteVerify) setupAccept() {
 
 	order := &ty.RelayAccept{
 		OrderId: s.orderID,
-		CoinAddr: "BTC",
+		XAddr:   "BTC",
 	}
 
 	tx := &types.Transaction{}
@@ -801,8 +801,8 @@ func (s *suiteVerify) setupAccept() {
 
 	var log ty.ReceiptRelayLog
 	types.Decode(receipt.Logs[len(receipt.Logs)-1].Log, &log)
-	s.Equal("200.0000", log.TxAmount)
-	s.Equal(uint64(20), log.CoinHeight)
+	s.Equal("200.0000", log.LocalCoinAmount)
+	s.Equal(uint64(20), log.XHeight)
 	s.Equal(ty.RelayOrderStatus_locking.String(), log.CurStatus)
 
 }
@@ -833,8 +833,8 @@ func (s *suiteVerify) setupConfirm() {
 
 	var log ty.ReceiptRelayLog
 	types.Decode(receipt.Logs[len(receipt.Logs)-1].Log, &log)
-	s.Equal("200.0000", log.TxAmount)
-	s.Equal(uint64(30), log.CoinHeight)
+	s.Equal("200.0000", log.LocalCoinAmount)
+	s.Equal(uint64(30), log.XHeight)
 	s.Equal(ty.RelayOrderStatus_confirming.String(), log.CurStatus)
 
 }
@@ -923,8 +923,8 @@ func (s *suiteVerify) TestVerify() {
 
 	var log ty.ReceiptRelayLog
 	types.Decode(receipt.Logs[len(receipt.Logs)-1].Log, &log)
-	//s.Equal("200.0000",log.TxAmount)
-	//s.Equal(uint64(30),log.CoinHeight)
+	//s.Equal("200.0000",log.LocalCoinAmount)
+	//s.Equal(uint64(30),log.XHeight)
 	s.Equal(ty.RelayOrderStatus_finished.String(), log.CurStatus)
 
 }
@@ -980,10 +980,10 @@ func (s *suiteVerifyCli) setupAccount() {
 func (s *suiteVerifyCli) setupRelayCreate() {
 	order := &ty.RelayCreate{
 		Operation:       ty.RelayOrderBuy,
-		Coin:      "BTC",
-		Amount:    0.299 * 1e8,
-		Addr:      addrBtc,
-		BtyAmount: 200 * 1e8,
+		XCoin:           "BTC",
+		XAmount:         0.299 * 1e8,
+		XAddr:           addrBtc,
+		LocalCoinAmount: 200 * 1e8,
 	}
 
 	tx := &types.Transaction{}
@@ -1006,17 +1006,17 @@ func (s *suiteVerifyCli) setupRelayCreate() {
 
 	var log ty.ReceiptRelayLog
 	types.Decode(receipt.Logs[len(receipt.Logs)-1].Log, &log)
-	s.Equal("200.0000", log.TxAmount)
-	s.Equal(uint64(10), log.CoinHeight)
+	s.Equal("200.0000", log.LocalCoinAmount)
+	s.Equal(uint64(10), log.XHeight)
 
-	s.orderID = log.OrderId
+	s.orderID = getRealTxHashID(log.OrderId)
 }
 
 func (s *suiteVerifyCli) setupAccept() {
 
 	order := &ty.RelayAccept{
 		OrderId: s.orderID,
-		CoinAddr: "BTC",
+		XAddr:   "BTC",
 	}
 
 	tx := &types.Transaction{}
@@ -1038,8 +1038,8 @@ func (s *suiteVerifyCli) setupAccept() {
 
 	var log ty.ReceiptRelayLog
 	types.Decode(receipt.Logs[len(receipt.Logs)-1].Log, &log)
-	s.Equal("200.0000", log.TxAmount)
-	s.Equal(uint64(20), log.CoinHeight)
+	s.Equal("200.0000", log.LocalCoinAmount)
+	s.Equal(uint64(20), log.XHeight)
 	s.Equal(ty.RelayOrderStatus_locking.String(), log.CurStatus)
 
 }
@@ -1070,8 +1070,8 @@ func (s *suiteVerifyCli) setupConfirm() {
 
 	var log ty.ReceiptRelayLog
 	types.Decode(receipt.Logs[len(receipt.Logs)-1].Log, &log)
-	s.Equal("200.0000", log.TxAmount)
-	s.Equal(uint64(30), log.CoinHeight)
+	s.Equal("200.0000", log.LocalCoinAmount)
+	s.Equal(uint64(30), log.XHeight)
 	s.Equal(ty.RelayOrderStatus_confirming.String(), log.CurStatus)
 
 }
@@ -1097,48 +1097,6 @@ func (s *suiteVerifyCli) SetupSuite() {
 	s.setupConfirm()
 }
 
-func (s *suiteVerifyCli) TestVerify() {
-	var head = &ty.BtcHeader{
-		Version:    1,
-		MerkleRoot: "f3e94742aca4b5ef85488dc37c06c3282295ffec960994b2c0d5ac2a25a95766",
-	}
-	headEnc := types.Encode(head)
-	s.kvdb.On("Get", mock.Anything).Return(headEnc, nil).Once()
-
-	order := &ty.RelayVerifyCli{
-		OrderId:    s.orderID,
-		RawTx:      "0100000001c33ebff2a709f13d9f9a7569ab16a32786af7d7e2de09265e41c61d078294ecf010000008a4730440220032d30df5ee6f57fa46cddb5eb8d0d9fe8de6b342d27942ae90a3231e0ba333e02203deee8060fdc70230a7f5b4ad7d7bc3e628cbe219a886b84269eaeb81e26b4fe014104ae31c31bf91278d99b8377a35bbce5b27d9fff15456839e919453fc7b3f721f0ba403ff96c9deeb680e5fd341c0fc3a7b90da4631ee39560639db462e9cb850fffffffff0240420f00000000001976a914b0dcbf97eabf4404e31d952477ce822dadbe7e1088acc060d211000000001976a9146b1281eec25ab4e1e0793ff4e08ab1abb3409cd988ac00000000",
-		TxIndex:    2,
-		MerkBranch: "e9a66845e05d5abc0ad04ec80f774a7e585c6e8db975962d069a522137b80c1d-ccdafb73d8dcd0173d5d5c3c9a0770d0b3953db889dab99ef05b1907518cb815",
-		BlockHash:  "000000000003ba27aa200b1cecaad478d2b00432346c3f1f3986da1afd33e506",
-	}
-
-	tx := &types.Transaction{Execer: []byte(ty.RelayX)}
-
-	tx.To = s.addrRelay
-	tx.Sign(types.SECP256K1, privTo)
-
-	s.relay.SetEnv(40, 4000, 1)
-	s.relayDb = newRelayDB(s.relay, tx)
-
-	receipt, err := s.relayDb.verifyCmdTx(order)
-	s.Nil(err)
-
-	acc := s.relay.GetCoinsAccount()
-	account := acc.LoadExecAccount(addrFrom, s.addrRelay)
-	//s.Equal(int64(200*1e8),account.Balance)
-	s.Zero(account.Frozen)
-	account = acc.LoadExecAccount(addrTo, s.addrRelay)
-	s.Equal(int64(400*1e8), account.Balance)
-	s.Zero(account.Frozen)
-
-	var log ty.ReceiptRelayLog
-	types.Decode(receipt.Logs[len(receipt.Logs)-1].Log, &log)
-
-	s.Equal(ty.RelayOrderStatus_finished.String(), log.CurStatus)
-
-}
-
 func TestRunSuiteVerifyCli(t *testing.T) {
 	log := new(suiteVerifyCli)
 	suite.Run(t, log)

plugin/dapp/relay/proto/relay.proto

@@ -28,13 +28,13 @@ message RelayOrder {
     string           id             = 1;
     RelayOrderStatus status         = 2;
     RelayOrderStatus preStatus      = 3;
-    uint64           amount        = 4;
+    uint64           localCoinAmount = 4;
     string           createrAddr    = 5;
-    uint32           coinOperation = 6;
-    string           coin          = 7;
-    uint64           coinAmount    = 8;
-    string           coinAddr      = 9;
-    string           coinTxHash    = 10;
+    uint32           operation      = 6;
+    string           xCoin          = 7;
+    uint64           xAmount        = 8;
+    string           xAddr          = 9;
+    string           xTxHash        = 10;
     int64            createTime     = 11;
     string           acceptAddr     = 12;
     int64            acceptTime     = 13;
@@ -42,23 +42,27 @@ message RelayOrder {
     int64            finishTime     = 15;
     string           finishTxHash   = 16;
     int64            height         = 17;
-    uint64           coinHeight    = 18;
-    uint32           coinWaits     = 19;
+    uint64           XHeight        = 18;
+    uint32           xBlockWaits    = 19;
+    string           localCoinSymbol = 20;
+    string           localCoinExec  = 21;
 }
 
 message RelayCreate {
     uint32 operation        = 1; // 0: buy, 1: sell
-    string coin      = 2; // outside coin BTC, ETH...
-    uint64 amount    = 3;
-    string addr      = 4;
-    uint64 btyAmount = 5;
-    uint32 coinWaits = 6; // the coin blocks to wait
+    string xCoin            = 2; // outside cross coin BTC, ETH...
+    uint64 xAmount          = 3;
+    string xAddr            = 4;
+    uint64 localCoinAmount  = 5;
+    uint32 xBlockWaits      = 6; // the coin blocks to wait
+    string localCoinSymbol  = 7;
+    string localCoinExec    = 8;
 }
 
 message RelayAccept {
     string orderId      = 1;
-    string coinAddr  = 2; // for sell coin case needed
-    uint32 coinWaits = 3;
+    string xAddr        = 2; // for sell coin case needed
+    uint32 xBlockWaits  = 3;
 }
 
 message RelayRevoke {
@@ -154,21 +158,23 @@ message ReceiptRelayLog {
     string orderId              = 1;
     string curStatus            = 2;
     string preStatus            = 3;
-    string txAmount      = 4;
+    string localCoinAmount      = 4;
     string createrAddr          = 5;
-    string coinOperation = 6;
-    string coin          = 7;
-    string coinAmount    = 8;
-    string coinAddr      = 9;
-    string coinTxHash    = 10;
+    uint32 coinOperation        = 6;
+    string xCoin                = 7;
+    string xAmount              = 8;
+    string xAddr                = 9;
+    string xTxHash              = 10;
     int64  createTime           = 11;
     string acceptAddr           = 12;
     int64  acceptTime           = 13;
     int64  confirmTime          = 14;
     int64  finishTime           = 15;
     string finishTxHash         = 16;
-    uint64 coinHeight    = 17;
-    uint32 coinWaits     = 18;
+    uint64 xHeight              = 17;
+    uint32 xBlockWaits          = 18;
+    string localCoinSymbol      = 19;
+    string localCoinExec        = 20;
 }
 
 message ReqRelayAddrCoins {

plugin/dapp/relay/rpc/jrpc_channel_test.go

@@ -42,11 +42,6 @@ func TestJRPCChannel(t *testing.T) {
 		{fn: testShowOnesAcceptRelayOrdersCmd},
 		{fn: testShowOnesStatusOrdersCmd},
 		{fn: testShowBTCHeadHeightListCmd},
-		{fn: testCreateRawRelayOrderTxCmd},
-		{fn: testCreateRawRelayAcceptTxCmd},
-		{fn: testCreateRawRevokeTxCmd},
-		{fn: testCreateRawRelayConfirmTxCmd},
-		{fn: testCreateRawRelayBtcHeaderCmd},
 		{fn: testGetBTCHeaderCurHeight},
 	}
 	for index, testCase := range testCases {
@@ -105,36 +100,6 @@ func testShowBTCHeadHeightListCmd(t *testing.T, jrpc *jsonclient.JSONClient) err
 	return jrpc.Call("Chain33.Query", params, rep)
 }
 
-func testCreateRawRelayOrderTxCmd(t *testing.T, jrpc *jsonclient.JSONClient) error {
-	params := pty.RelayCreate{}
-	var res string
-	return jrpc.Call("relay.CreateRawRelayOrderTx", params, &res)
-}
-
-func testCreateRawRelayAcceptTxCmd(t *testing.T, jrpc *jsonclient.JSONClient) error {
-	params := pty.RelayAccept{}
-	var res string
-	return jrpc.Call("relay.CreateRawRelayAcceptTx", params, &res)
-}
-
-func testCreateRawRevokeTxCmd(t *testing.T, jrpc *jsonclient.JSONClient) error {
-	params := pty.RelayRevoke{}
-	var res string
-	return jrpc.Call("relay.CreateRawRelayRevokeTx", params, &res)
-}
-
-func testCreateRawRelayConfirmTxCmd(t *testing.T, jrpc *jsonclient.JSONClient) error {
-	params := pty.RelayConfirmTx{}
-	var res string
-	return jrpc.Call("relay.CreateRawRelayConfirmTx", params, &res)
-}
-
-func testCreateRawRelayBtcHeaderCmd(t *testing.T, jrpc *jsonclient.JSONClient) error {
-	params := pty.BtcHeader{}
-	var res string
-	return jrpc.Call("relay.CreateRawRelaySaveBTCHeadTx", params, &res)
-}
-
 func testGetBTCHeaderCurHeight(t *testing.T, jrpc *jsonclient.JSONClient) error {
 	var params rpctypes.Query4Jrpc
 	req := &pty.ReqRelayBtcHeaderHeightList{}

plugin/dapp/relay/rpc/rpc.go

@@ -3,119 +3,3 @@
 // license that can be found in the LICENSE file.
 
 package rpc
-
-import (
-	"encoding/hex"
-
-	"github.com/33cn/chain33/types"
-	ty "github.com/33cn/plugin/plugin/dapp/relay/types"
-)
-
-func createRawRelayOrderTx(cfg *types.Chain33Config, parm *ty.RelayCreate) ([]byte, error) {
-	if parm == nil {
-		return nil, types.ErrInvalidParam
-	}
-	v := *parm
-	return types.CallCreateTx(cfg, cfg.ExecName(ty.RelayX), "Create", &v)
-}
-
-func createRawRelayAcceptTx(cfg *types.Chain33Config, parm *ty.RelayAccept) ([]byte, error) {
-	if parm == nil {
-		return nil, types.ErrInvalidParam
-	}
-	return types.CallCreateTx(cfg, cfg.ExecName(ty.RelayX), "Accept", parm)
-}
-
-func createRawRelayRevokeTx(cfg *types.Chain33Config, parm *ty.RelayRevoke) ([]byte, error) {
-	if parm == nil {
-		return nil, types.ErrInvalidParam
-	}
-	return types.CallCreateTx(cfg, cfg.ExecName(ty.RelayX), "Revoke", parm)
-}
-
-func createRawRelayConfirmTx(cfg *types.Chain33Config, parm *ty.RelayConfirmTx) ([]byte, error) {
-	if parm == nil {
-		return nil, types.ErrInvalidParam
-	}
-
-	return types.CallCreateTx(cfg, cfg.ExecName(ty.RelayX), "ConfirmTx", parm)
-}
-
-func createRawRelaySaveBTCHeadTx(cfg *types.Chain33Config, parm *ty.BtcHeader) ([]byte, error) {
-	if parm == nil {
-		return nil, types.ErrInvalidParam
-	}
-	head := &ty.BtcHeader{
-		Hash:         parm.Hash,
-		PreviousHash: parm.PreviousHash,
-		MerkleRoot:   parm.MerkleRoot,
-		Height:       parm.Height,
-		Version:      parm.Version,
-		Time:         parm.Time,
-		Nonce:        parm.Nonce,
-		Bits:         parm.Bits,
-		IsReset:      parm.IsReset,
-	}
-
-	v := &ty.BtcHeaders{}
-	v.BtcHeader = append(v.BtcHeader, head)
-	return types.CallCreateTx(cfg, cfg.ExecName(ty.RelayX), "BtcHeaders", v)
-}
-
-//CreateRawRelayOrderTx jrpc create raw relay order
-func (c *Jrpc) CreateRawRelayOrderTx(in *ty.RelayCreate, result *interface{}) error {
-	cfg := c.cli.GetConfig()
-	reply, err := createRawRelayOrderTx(cfg, in)
-	if err != nil {
-		return err
-	}
-	*result = hex.EncodeToString(reply)
-	return nil
-}
-
-//CreateRawRelayAcceptTx jrpc creat relay accept tx
-func (c *Jrpc) CreateRawRelayAcceptTx(in *ty.RelayAccept, result *interface{}) error {
-	cfg := c.cli.GetConfig()
-	reply, err := createRawRelayAcceptTx(cfg, in)
-	if err != nil {
-		return err
-	}
-
-	*result = hex.EncodeToString(reply)
-	return nil
-}
-
-//CreateRawRelayRevokeTx jrpc create revoke tx
-func (c *Jrpc) CreateRawRelayRevokeTx(in *ty.RelayRevoke, result *interface{}) error {
-	cfg := c.cli.GetConfig()
-	reply, err := createRawRelayRevokeTx(cfg, in)
-	if err != nil {
-		return err
-	}
-
-	*result = hex.EncodeToString(reply)
-	return nil
-}
-
-//CreateRawRelayConfirmTx jrpc create confirm tx
-func (c *Jrpc) CreateRawRelayConfirmTx(in *ty.RelayConfirmTx, result *interface{}) error {
-	cfg := c.cli.GetConfig()
-	reply, err := createRawRelayConfirmTx(cfg, in)
-	if err != nil {
-		return err
-	}
-
-	*result = hex.EncodeToString(reply)
-	return nil
-}
-
-//CreateRawRelaySaveBTCHeadTx jrpc save btc header
-func (c *Jrpc) CreateRawRelaySaveBTCHeadTx(in *ty.BtcHeader, result *interface{}) error {
-	cfg := c.cli.GetConfig()
-	reply, err := createRawRelaySaveBTCHeadTx(cfg, in)
-	if err != nil {
-		return err
-	}
-	*result = hex.EncodeToString(reply)
-	return nil
-}

plugin/dapp/relay/types/relay.go

@@ -5,7 +5,6 @@
 package types
 
 import (
-	"encoding/json"
 	"reflect"
 
 	//log "github.com/33cn/chain33/common/log/log15"
@@ -42,12 +41,6 @@ const (
 	RelayOrderSell
 )
 
-// RelayOrderOperation buy or sell operation
-var RelayOrderOperation = map[uint32]string{
-	RelayOrderBuy:  "buy",
-	RelayOrderSell: "sell",
-}
-
 const (
 	// RelayUnlock revoke order
 	RelayUnlock = iota
@@ -171,13 +164,7 @@ func (r *RelayType) Amount(tx *types.Transaction) (int64, error) {
 	}
 	relay := data.(*RelayAction)
 	if RelayActionCreate == relay.Ty && relay.GetCreate() != nil {
-		return int64(relay.GetCreate().BtyAmount), nil
+		return int64(relay.GetCreate().LocalCoinAmount), nil
 	}
 	return 0, nil
 }
-
-// CreateTx relay create tx TODO 暂时不修改实现， 先完成结构的重构
-func (r *RelayType) CreateTx(action string, message json.RawMessage) (*types.Transaction, error) {
-	var tx *types.Transaction
-	return tx, nil
-}

plugin/dapp/relay/types/relay.pb.go

@@ -57,7 +57,7 @@ func (x RelayOrderStatus) String() string {
 	return proto.EnumName(RelayOrderStatus_name, int32(x))
 }
 func (RelayOrderStatus) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_relay_9047ae8d90541176, []int{0}
+	return fileDescriptor_relay_1037c107938271b1, []int{0}
 }
 
 type RelayAction struct {
@@ -80,7 +80,7 @@ func (m *RelayAction) Reset()         { *m = RelayAction{} }
 func (m *RelayAction) String() string { return proto.CompactTextString(m) }
 func (*RelayAction) ProtoMessage()    {}
 func (*RelayAction) Descriptor() ([]byte, []int) {
-	return fileDescriptor_relay_9047ae8d90541176, []int{0}
+	return fileDescriptor_relay_1037c107938271b1, []int{0}
 }
 func (m *RelayAction) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_RelayAction.Unmarshal(m, b)
@@ -382,13 +382,13 @@ type RelayOrder struct {
 	Id                   string           `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
 	Status               RelayOrderStatus `protobuf:"varint,2,opt,name=status,proto3,enum=types.RelayOrderStatus" json:"status,omitempty"`
 	PreStatus            RelayOrderStatus `protobuf:"varint,3,opt,name=preStatus,proto3,enum=types.RelayOrderStatus" json:"preStatus,omitempty"`
-	Amount               uint64           `protobuf:"varint,4,opt,name=amount,proto3" json:"amount,omitempty"`
+	LocalCoinAmount      uint64           `protobuf:"varint,4,opt,name=localCoinAmount,proto3" json:"localCoinAmount,omitempty"`
 	CreaterAddr          string           `protobuf:"bytes,5,opt,name=createrAddr,proto3" json:"createrAddr,omitempty"`
-	CoinOperation        uint32           `protobuf:"varint,6,opt,name=coinOperation,proto3" json:"coinOperation,omitempty"`
-	Coin                 string           `protobuf:"bytes,7,opt,name=coin,proto3" json:"coin,omitempty"`
-	CoinAmount           uint64           `protobuf:"varint,8,opt,name=coinAmount,proto3" json:"coinAmount,omitempty"`
-	CoinAddr             string           `protobuf:"bytes,9,opt,name=coinAddr,proto3" json:"coinAddr,omitempty"`
-	CoinTxHash           string           `protobuf:"bytes,10,opt,name=coinTxHash,proto3" json:"coinTxHash,omitempty"`
+	Operation            uint32           `protobuf:"varint,6,opt,name=operation,proto3" json:"operation,omitempty"`
+	XCoin                string           `protobuf:"bytes,7,opt,name=xCoin,proto3" json:"xCoin,omitempty"`
+	XAmount              uint64           `protobuf:"varint,8,opt,name=xAmount,proto3" json:"xAmount,omitempty"`
+	XAddr                string           `protobuf:"bytes,9,opt,name=xAddr,proto3" json:"xAddr,omitempty"`
+	XTxHash              string           `protobuf:"bytes,10,opt,name=xTxHash,proto3" json:"xTxHash,omitempty"`
 	CreateTime           int64            `protobuf:"varint,11,opt,name=createTime,proto3" json:"createTime,omitempty"`
 	AcceptAddr           string           `protobuf:"bytes,12,opt,name=acceptAddr,proto3" json:"acceptAddr,omitempty"`
 	AcceptTime           int64            `protobuf:"varint,13,opt,name=acceptTime,proto3" json:"acceptTime,omitempty"`
@@ -396,8 +396,10 @@ type RelayOrder struct {
 	FinishTime           int64            `protobuf:"varint,15,opt,name=finishTime,proto3" json:"finishTime,omitempty"`
 	FinishTxHash         string           `protobuf:"bytes,16,opt,name=finishTxHash,proto3" json:"finishTxHash,omitempty"`
 	Height               int64            `protobuf:"varint,17,opt,name=height,proto3" json:"height,omitempty"`
-	CoinHeight           uint64           `protobuf:"varint,18,opt,name=coinHeight,proto3" json:"coinHeight,omitempty"`
-	CoinWaits            uint32           `protobuf:"varint,19,opt,name=coinWaits,proto3" json:"coinWaits,omitempty"`
+	XHeight              uint64           `protobuf:"varint,18,opt,name=XHeight,proto3" json:"XHeight,omitempty"`
+	XBlockWaits          uint32           `protobuf:"varint,19,opt,name=xBlockWaits,proto3" json:"xBlockWaits,omitempty"`
+	LocalCoinSymbol      string           `protobuf:"bytes,20,opt,name=localCoinSymbol,proto3" json:"localCoinSymbol,omitempty"`
+	LocalCoinExec        string           `protobuf:"bytes,21,opt,name=localCoinExec,proto3" json:"localCoinExec,omitempty"`
 	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
 	XXX_unrecognized     []byte           `json:"-"`
 	XXX_sizecache        int32            `json:"-"`
@@ -407,7 +409,7 @@ func (m *RelayOrder) Reset()         { *m = RelayOrder{} }
 func (m *RelayOrder) String() string { return proto.CompactTextString(m) }
 func (*RelayOrder) ProtoMessage()    {}
 func (*RelayOrder) Descriptor() ([]byte, []int) {
-	return fileDescriptor_relay_9047ae8d90541176, []int{1}
+	return fileDescriptor_relay_1037c107938271b1, []int{1}
 }
 func (m *RelayOrder) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_RelayOrder.Unmarshal(m, b)
@@ -448,9 +450,9 @@ func (m *RelayOrder) GetPreStatus() RelayOrderStatus {
 	return RelayOrderStatus_init
 }
 
-func (m *RelayOrder) GetAmount() uint64 {
+func (m *RelayOrder) GetLocalCoinAmount() uint64 {
 	if m != nil {
-		return m.Amount
+		return m.LocalCoinAmount
 	}
 	return 0
 }
@@ -462,37 +464,37 @@ func (m *RelayOrder) GetCreaterAddr() string {
 	return ""
 }
 
-func (m *RelayOrder) GetCoinOperation() uint32 {
+func (m *RelayOrder) GetOperation() uint32 {
 	if m != nil {
-		return m.CoinOperation
+		return m.Operation
 	}
 	return 0
 }
 
-func (m *RelayOrder) GetCoin() string {
+func (m *RelayOrder) GetXCoin() string {
 	if m != nil {
-		return m.Coin
+		return m.XCoin
 	}
 	return ""
 }
 
-func (m *RelayOrder) GetCoinAmount() uint64 {
+func (m *RelayOrder) GetXAmount() uint64 {
 	if m != nil {
-		return m.CoinAmount
+		return m.XAmount
 	}
 	return 0
 }
 
-func (m *RelayOrder) GetCoinAddr() string {
+func (m *RelayOrder) GetXAddr() string {
 	if m != nil {
-		return m.CoinAddr
+		return m.XAddr
 	}
 	return ""
 }
 
-func (m *RelayOrder) GetCoinTxHash() string {
+func (m *RelayOrder) GetXTxHash() string {
 	if m != nil {
-		return m.CoinTxHash
+		return m.XTxHash
 	}
 	return ""
 }
@@ -546,27 +548,43 @@ func (m *RelayOrder) GetHeight() int64 {
 	return 0
 }
 
-func (m *RelayOrder) GetCoinHeight() uint64 {
+func (m *RelayOrder) GetXHeight() uint64 {
 	if m != nil {
-		return m.CoinHeight
+		return m.XHeight
 	}
 	return 0
 }
 
-func (m *RelayOrder) GetCoinWaits() uint32 {
+func (m *RelayOrder) GetXBlockWaits() uint32 {
 	if m != nil {
-		return m.CoinWaits
+		return m.XBlockWaits
 	}
 	return 0
 }
 
+func (m *RelayOrder) GetLocalCoinSymbol() string {
+	if m != nil {
+		return m.LocalCoinSymbol
+	}
+	return ""
+}
+
+func (m *RelayOrder) GetLocalCoinExec() string {
+	if m != nil {
+		return m.LocalCoinExec
+	}
+	return ""
+}
+
 type RelayCreate struct {
 	Operation            uint32   `protobuf:"varint,1,opt,name=operation,proto3" json:"operation,omitempty"`
-	Coin                 string   `protobuf:"bytes,2,opt,name=coin,proto3" json:"coin,omitempty"`
-	Amount               uint64   `protobuf:"varint,3,opt,name=amount,proto3" json:"amount,omitempty"`
-	Addr                 string   `protobuf:"bytes,4,opt,name=addr,proto3" json:"addr,omitempty"`
-	BtyAmount            uint64   `protobuf:"varint,5,opt,name=btyAmount,proto3" json:"btyAmount,omitempty"`
-	CoinWaits            uint32   `protobuf:"varint,6,opt,name=coinWaits,proto3" json:"coinWaits,omitempty"`
+	XCoin                string   `protobuf:"bytes,2,opt,name=xCoin,proto3" json:"xCoin,omitempty"`
+	XAmount              uint64   `protobuf:"varint,3,opt,name=xAmount,proto3" json:"xAmount,omitempty"`
+	XAddr                string   `protobuf:"bytes,4,opt,name=xAddr,proto3" json:"xAddr,omitempty"`
+	LocalCoinAmount      uint64   `protobuf:"varint,5,opt,name=localCoinAmount,proto3" json:"localCoinAmount,omitempty"`
+	XBlockWaits          uint32   `protobuf:"varint,6,opt,name=xBlockWaits,proto3" json:"xBlockWaits,omitempty"`
+	LocalCoinSymbol      string   `protobuf:"bytes,7,opt,name=localCoinSymbol,proto3" json:"localCoinSymbol,omitempty"`
+	LocalCoinExec        string   `protobuf:"bytes,8,opt,name=localCoinExec,proto3" json:"localCoinExec,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -576,7 +594,7 @@ func (m *RelayCreate) Reset()         { *m = RelayCreate{} }
 func (m *RelayCreate) String() string { return proto.CompactTextString(m) }
 func (*RelayCreate) ProtoMessage()    {}
 func (*RelayCreate) Descriptor() ([]byte, []int) {
-	return fileDescriptor_relay_9047ae8d90541176, []int{2}
+	return fileDescriptor_relay_1037c107938271b1, []int{2}
 }
 func (m *RelayCreate) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_RelayCreate.Unmarshal(m, b)
@@ -603,45 +621,59 @@ func (m *RelayCreate) GetOperation() uint32 {
 	return 0
 }
 
-func (m *RelayCreate) GetCoin() string {
+func (m *RelayCreate) GetXCoin() string {
 	if m != nil {
-		return m.Coin
+		return m.XCoin
 	}
 	return ""
 }
 
-func (m *RelayCreate) GetAmount() uint64 {
+func (m *RelayCreate) GetXAmount() uint64 {
 	if m != nil {
-		return m.Amount
+		return m.XAmount
 	}
 	return 0
 }
 
-func (m *RelayCreate) GetAddr() string {
+func (m *RelayCreate) GetXAddr() string {
 	if m != nil {
-		return m.Addr
+		return m.XAddr
 	}
 	return ""
 }
 
-func (m *RelayCreate) GetBtyAmount() uint64 {
+func (m *RelayCreate) GetLocalCoinAmount() uint64 {
 	if m != nil {
-		return m.BtyAmount
+		return m.LocalCoinAmount
 	}
 	return 0
 }
 
-func (m *RelayCreate) GetCoinWaits() uint32 {
+func (m *RelayCreate) GetXBlockWaits() uint32 {
 	if m != nil {
-		return m.CoinWaits
+		return m.XBlockWaits
 	}
 	return 0
 }
 
+func (m *RelayCreate) GetLocalCoinSymbol() string {
+	if m != nil {
+		return m.LocalCoinSymbol
+	}
+	return ""
+}
+
+func (m *RelayCreate) GetLocalCoinExec() string {
+	if m != nil {
+		return m.LocalCoinExec
+	}
+	return ""
+}
+
 type RelayAccept struct {
 	OrderId              string   `protobuf:"bytes,1,opt,name=orderId,proto3" json:"orderId,omitempty"`
-	CoinAddr             string   `protobuf:"bytes,2,opt,name=coinAddr,proto3" json:"coinAddr,omitempty"`
-	CoinWaits            uint32   `protobuf:"varint,3,opt,name=coinWaits,proto3" json:"coinWaits,omitempty"`
+	XAddr                string   `protobuf:"bytes,2,opt,name=xAddr,proto3" json:"xAddr,omitempty"`
+	XBlockWaits          uint32   `protobuf:"varint,3,opt,name=xBlockWaits,proto3" json:"xBlockWaits,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -651,7 +683,7 @@ func (m *RelayAccept) Reset()         { *m = RelayAccept{} }
 func (m *RelayAccept) String() string { return proto.CompactTextString(m) }
 func (*RelayAccept) ProtoMessage()    {}
 func (*RelayAccept) Descriptor() ([]byte, []int) {
-	return fileDescriptor_relay_9047ae8d90541176, []int{3}
+	return fileDescriptor_relay_1037c107938271b1, []int{3}
 }
 func (m *RelayAccept) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_RelayAccept.Unmarshal(m, b)
@@ -678,16 +710,16 @@ func (m *RelayAccept) GetOrderId() string {
 	return ""
 }
 
-func (m *RelayAccept) GetCoinAddr() string {
+func (m *RelayAccept) GetXAddr() string {
 	if m != nil {
-		return m.CoinAddr
+		return m.XAddr
 	}
 	return ""
 }
 
-func (m *RelayAccept) GetCoinWaits() uint32 {
+func (m *RelayAccept) GetXBlockWaits() uint32 {
 	if m != nil {
-		return m.CoinWaits
+		return m.XBlockWaits
 	}
 	return 0
 }
@@ -705,7 +737,7 @@ func (m *RelayRevoke) Reset()         { *m = RelayRevoke{} }
 func (m *RelayRevoke) String() string { return proto.CompactTextString(m) }
 func (*RelayRevoke) ProtoMessage()    {}
 func (*RelayRevoke) Descriptor() ([]byte, []int) {
-	return fileDescriptor_relay_9047ae8d90541176, []int{4}
+	return fileDescriptor_relay_1037c107938271b1, []int{4}
 }
 func (m *RelayRevoke) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_RelayRevoke.Unmarshal(m, b)
@@ -759,7 +791,7 @@ func (m *RelayConfirmTx) Reset()         { *m = RelayConfirmTx{} }
 func (m *RelayConfirmTx) String() string { return proto.CompactTextString(m) }
 func (*RelayConfirmTx) ProtoMessage()    {}
 func (*RelayConfirmTx) Descriptor() ([]byte, []int) {
-	return fileDescriptor_relay_9047ae8d90541176, []int{5}
+	return fileDescriptor_relay_1037c107938271b1, []int{5}
 }
 func (m *RelayConfirmTx) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_RelayConfirmTx.Unmarshal(m, b)
@@ -807,7 +839,7 @@ func (m *RelayVerify) Reset()         { *m = RelayVerify{} }
 func (m *RelayVerify) String() string { return proto.CompactTextString(m) }
 func (*RelayVerify) ProtoMessage()    {}
 func (*RelayVerify) Descriptor() ([]byte, []int) {
-	return fileDescriptor_relay_9047ae8d90541176, []int{6}
+	return fileDescriptor_relay_1037c107938271b1, []int{6}
 }
 func (m *RelayVerify) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_RelayVerify.Unmarshal(m, b)
@@ -863,7 +895,7 @@ func (m *RelayVerifyCli) Reset()         { *m = RelayVerifyCli{} }
 func (m *RelayVerifyCli) String() string { return proto.CompactTextString(m) }
 func (*RelayVerifyCli) ProtoMessage()    {}
 func (*RelayVerifyCli) Descriptor() ([]byte, []int) {
-	return fileDescriptor_relay_9047ae8d90541176, []int{7}
+	return fileDescriptor_relay_1037c107938271b1, []int{7}
 }
 func (m *RelayVerifyCli) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_RelayVerifyCli.Unmarshal(m, b)
@@ -940,7 +972,7 @@ func (m *BtcHeader) Reset()         { *m = BtcHeader{} }
 func (m *BtcHeader) String() string { return proto.CompactTextString(m) }
 func (*BtcHeader) ProtoMessage()    {}
 func (*BtcHeader) Descriptor() ([]byte, []int) {
-	return fileDescriptor_relay_9047ae8d90541176, []int{8}
+	return fileDescriptor_relay_1037c107938271b1, []int{8}
 }
 func (m *BtcHeader) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_BtcHeader.Unmarshal(m, b)
@@ -1055,7 +1087,7 @@ func (m *BtcHeaders) Reset()         { *m = BtcHeaders{} }
 func (m *BtcHeaders) String() string { return proto.CompactTextString(m) }
 func (*BtcHeaders) ProtoMessage()    {}
 func (*BtcHeaders) Descriptor() ([]byte, []int) {
-	return fileDescriptor_relay_9047ae8d90541176, []int{9}
+	return fileDescriptor_relay_1037c107938271b1, []int{9}
 }
 func (m *BtcHeaders) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_BtcHeaders.Unmarshal(m, b)
@@ -1098,7 +1130,7 @@ func (m *BtcTransaction) Reset()         { *m = BtcTransaction{} }
 func (m *BtcTransaction) String() string { return proto.CompactTextString(m) }
 func (*BtcTransaction) ProtoMessage()    {}
 func (*BtcTransaction) Descriptor() ([]byte, []int) {
-	return fileDescriptor_relay_9047ae8d90541176, []int{10}
+	return fileDescriptor_relay_1037c107938271b1, []int{10}
 }
 func (m *BtcTransaction) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_BtcTransaction.Unmarshal(m, b)
@@ -1172,7 +1204,7 @@ func (m *Vin) Reset()         { *m = Vin{} }
 func (m *Vin) String() string { return proto.CompactTextString(m) }
 func (*Vin) ProtoMessage()    {}
 func (*Vin) Descriptor() ([]byte, []int) {
-	return fileDescriptor_relay_9047ae8d90541176, []int{11}
+	return fileDescriptor_relay_1037c107938271b1, []int{11}
 }
 func (m *Vin) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_Vin.Unmarshal(m, b)
@@ -1219,7 +1251,7 @@ func (m *Vout) Reset()         { *m = Vout{} }
 func (m *Vout) String() string { return proto.CompactTextString(m) }
 func (*Vout) ProtoMessage()    {}
 func (*Vout) Descriptor() ([]byte, []int) {
-	return fileDescriptor_relay_9047ae8d90541176, []int{12}
+	return fileDescriptor_relay_1037c107938271b1, []int{12}
 }
 func (m *Vout) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_Vout.Unmarshal(m, b)
@@ -1276,7 +1308,7 @@ func (m *BtcSpv) Reset()         { *m = BtcSpv{} }
 func (m *BtcSpv) String() string { return proto.CompactTextString(m) }
 func (*BtcSpv) ProtoMessage()    {}
 func (*BtcSpv) Descriptor() ([]byte, []int) {
-	return fileDescriptor_relay_9047ae8d90541176, []int{13}
+	return fileDescriptor_relay_1037c107938271b1, []int{13}
 }
 func (m *BtcSpv) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_BtcSpv.Unmarshal(m, b)
@@ -1350,7 +1382,7 @@ func (m *RelayLastRcvBtcHeader) Reset()         { *m = RelayLastRcvBtcHeader{} }
 func (m *RelayLastRcvBtcHeader) String() string { return proto.CompactTextString(m) }
 func (*RelayLastRcvBtcHeader) ProtoMessage()    {}
 func (*RelayLastRcvBtcHeader) Descriptor() ([]byte, []int) {
-	return fileDescriptor_relay_9047ae8d90541176, []int{14}
+	return fileDescriptor_relay_1037c107938271b1, []int{14}
 }
 func (m *RelayLastRcvBtcHeader) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_RelayLastRcvBtcHeader.Unmarshal(m, b)
@@ -1399,7 +1431,7 @@ func (m *ReceiptRelayRcvBTCHeaders) Reset()         { *m = ReceiptRelayRcvBTCHea
 func (m *ReceiptRelayRcvBTCHeaders) String() string { return proto.CompactTextString(m) }
 func (*ReceiptRelayRcvBTCHeaders) ProtoMessage()    {}
 func (*ReceiptRelayRcvBTCHeaders) Descriptor() ([]byte, []int) {
-	return fileDescriptor_relay_9047ae8d90541176, []int{15}
+	return fileDescriptor_relay_1037c107938271b1, []int{15}
 }
 func (m *ReceiptRelayRcvBTCHeaders) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ReceiptRelayRcvBTCHeaders.Unmarshal(m, b)
@@ -1458,21 +1490,23 @@ type ReceiptRelayLog struct {
 	OrderId              string   `protobuf:"bytes,1,opt,name=orderId,proto3" json:"orderId,omitempty"`
 	CurStatus            string   `protobuf:"bytes,2,opt,name=curStatus,proto3" json:"curStatus,omitempty"`
 	PreStatus            string   `protobuf:"bytes,3,opt,name=preStatus,proto3" json:"preStatus,omitempty"`
-	TxAmount             string   `protobuf:"bytes,4,opt,name=txAmount,proto3" json:"txAmount,omitempty"`
+	LocalCoinAmount      string   `protobuf:"bytes,4,opt,name=localCoinAmount,proto3" json:"localCoinAmount,omitempty"`
 	CreaterAddr          string   `protobuf:"bytes,5,opt,name=createrAddr,proto3" json:"createrAddr,omitempty"`
-	CoinOperation        string   `protobuf:"bytes,6,opt,name=coinOperation,proto3" json:"coinOperation,omitempty"`
-	Coin                 string   `protobuf:"bytes,7,opt,name=coin,proto3" json:"coin,omitempty"`
-	CoinAmount           string   `protobuf:"bytes,8,opt,name=coinAmount,proto3" json:"coinAmount,omitempty"`
-	CoinAddr             string   `protobuf:"bytes,9,opt,name=coinAddr,proto3" json:"coinAddr,omitempty"`
-	CoinTxHash           string   `protobuf:"bytes,10,opt,name=coinTxHash,proto3" json:"coinTxHash,omitempty"`
+	CoinOperation        uint32   `protobuf:"varint,6,opt,name=coinOperation,proto3" json:"coinOperation,omitempty"`
+	XCoin                string   `protobuf:"bytes,7,opt,name=xCoin,proto3" json:"xCoin,omitempty"`
+	XAmount              string   `protobuf:"bytes,8,opt,name=xAmount,proto3" json:"xAmount,omitempty"`
+	XAddr                string   `protobuf:"bytes,9,opt,name=xAddr,proto3" json:"xAddr,omitempty"`
+	XTxHash              string   `protobuf:"bytes,10,opt,name=xTxHash,proto3" json:"xTxHash,omitempty"`
 	CreateTime           int64    `protobuf:"varint,11,opt,name=createTime,proto3" json:"createTime,omitempty"`
 	AcceptAddr           string   `protobuf:"bytes,12,opt,name=acceptAddr,proto3" json:"acceptAddr,omitempty"`
 	AcceptTime           int64    `protobuf:"varint,13,opt,name=acceptTime,proto3" json:"acceptTime,omitempty"`
 	ConfirmTime          int64    `protobuf:"varint,14,opt,name=confirmTime,proto3" json:"confirmTime,omitempty"`
 	FinishTime           int64    `protobuf:"varint,15,opt,name=finishTime,proto3" json:"finishTime,omitempty"`
 	FinishTxHash         string   `protobuf:"bytes,16,opt,name=finishTxHash,proto3" json:"finishTxHash,omitempty"`
-	CoinHeight           uint64   `protobuf:"varint,17,opt,name=coinHeight,proto3" json:"coinHeight,omitempty"`
-	CoinWaits            uint32   `protobuf:"varint,18,opt,name=coinWaits,proto3" json:"coinWaits,omitempty"`
+	XHeight              uint64   `protobuf:"varint,17,opt,name=xHeight,proto3" json:"xHeight,omitempty"`
+	XBlockWaits          uint32   `protobuf:"varint,18,opt,name=xBlockWaits,proto3" json:"xBlockWaits,omitempty"`
+	LocalCoinSymbol      string   `protobuf:"bytes,19,opt,name=localCoinSymbol,proto3" json:"localCoinSymbol,omitempty"`
+	LocalCoinExec        string   `protobuf:"bytes,20,opt,name=localCoinExec,proto3" json:"localCoinExec,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -1482,7 +1516,7 @@ func (m *ReceiptRelayLog) Reset()         { *m = ReceiptRelayLog{} }
 func (m *ReceiptRelayLog) String() string { return proto.CompactTextString(m) }
 func (*ReceiptRelayLog) ProtoMessage()    {}
 func (*ReceiptRelayLog) Descriptor() ([]byte, []int) {
-	return fileDescriptor_relay_9047ae8d90541176, []int{16}
+	return fileDescriptor_relay_1037c107938271b1, []int{16}
 }
 func (m *ReceiptRelayLog) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ReceiptRelayLog.Unmarshal(m, b)
@@ -1523,9 +1557,9 @@ func (m *ReceiptRelayLog) GetPreStatus() string {
 	return ""
 }
 
-func (m *ReceiptRelayLog) GetTxAmount() string {
+func (m *ReceiptRelayLog) GetLocalCoinAmount() string {
 	if m != nil {
-		return m.TxAmount
+		return m.LocalCoinAmount
 	}
 	return ""
 }
@@ -1537,37 +1571,37 @@ func (m *ReceiptRelayLog) GetCreaterAddr() string {
 	return ""
 }
 
-func (m *ReceiptRelayLog) GetCoinOperation() string {
+func (m *ReceiptRelayLog) GetCoinOperation() uint32 {
 	if m != nil {
 		return m.CoinOperation
 	}
-	return ""
+	return 0
 }
 
-func (m *ReceiptRelayLog) GetCoin() string {
+func (m *ReceiptRelayLog) GetXCoin() string {
 	if m != nil {
-		return m.Coin
+		return m.XCoin
 	}
 	return ""
 }
 
-func (m *ReceiptRelayLog) GetCoinAmount() string {
+func (m *ReceiptRelayLog) GetXAmount() string {
 	if m != nil {
-		return m.CoinAmount
+		return m.XAmount
 	}
 	return ""
 }
 
-func (m *ReceiptRelayLog) GetCoinAddr() string {
+func (m *ReceiptRelayLog) GetXAddr() string {
 	if m != nil {
-		return m.CoinAddr
+		return m.XAddr
 	}
 	return ""
 }
 
-func (m *ReceiptRelayLog) GetCoinTxHash() string {
+func (m *ReceiptRelayLog) GetXTxHash() string {
 	if m != nil {
-		return m.CoinTxHash
+		return m.XTxHash
 	}
 	return ""
 }
@@ -1614,20 +1648,34 @@ func (m *ReceiptRelayLog) GetFinishTxHash() string {
 	return ""
 }
 
-func (m *ReceiptRelayLog) GetCoinHeight() uint64 {
+func (m *ReceiptRelayLog) GetXHeight() uint64 {
 	if m != nil {
-		return m.CoinHeight
+		return m.XHeight
 	}
 	return 0
 }
 
-func (m *ReceiptRelayLog) GetCoinWaits() uint32 {
+func (m *ReceiptRelayLog) GetXBlockWaits() uint32 {
 	if m != nil {
-		return m.CoinWaits
+		return m.XBlockWaits
 	}
 	return 0
 }
 
+func (m *ReceiptRelayLog) GetLocalCoinSymbol() string {
+	if m != nil {
+		return m.LocalCoinSymbol
+	}
+	return ""
+}
+
+func (m *ReceiptRelayLog) GetLocalCoinExec() string {
+	if m != nil {
+		return m.LocalCoinExec
+	}
+	return ""
+}
+
 type ReqRelayAddrCoins struct {
 	Addr                 string           `protobuf:"bytes,1,opt,name=addr,proto3" json:"addr,omitempty"`
 	Status               RelayOrderStatus `protobuf:"varint,2,opt,name=status,proto3,enum=types.RelayOrderStatus" json:"status,omitempty"`
@@ -1643,7 +1691,7 @@ func (m *ReqRelayAddrCoins) Reset()         { *m = ReqRelayAddrCoins{} }
 func (m *ReqRelayAddrCoins) String() string { return proto.CompactTextString(m) }
 func (*ReqRelayAddrCoins) ProtoMessage()    {}
 func (*ReqRelayAddrCoins) Descriptor() ([]byte, []int) {
-	return fileDescriptor_relay_9047ae8d90541176, []int{17}
+	return fileDescriptor_relay_1037c107938271b1, []int{17}
 }
 func (m *ReqRelayAddrCoins) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ReqRelayAddrCoins.Unmarshal(m, b)
@@ -1709,7 +1757,7 @@ func (m *ReplyRelayOrders) Reset()         { *m = ReplyRelayOrders{} }
 func (m *ReplyRelayOrders) String() string { return proto.CompactTextString(m) }
 func (*ReplyRelayOrders) ProtoMessage()    {}
 func (*ReplyRelayOrders) Descriptor() ([]byte, []int) {
-	return fileDescriptor_relay_9047ae8d90541176, []int{18}
+	return fileDescriptor_relay_1037c107938271b1, []int{18}
 }
 func (m *ReplyRelayOrders) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ReplyRelayOrders.Unmarshal(m, b)
@@ -1748,7 +1796,7 @@ func (m *QueryRelayOrderParam) Reset()         { *m = QueryRelayOrderParam{} }
 func (m *QueryRelayOrderParam) String() string { return proto.CompactTextString(m) }
 func (*QueryRelayOrderParam) ProtoMessage()    {}
 func (*QueryRelayOrderParam) Descriptor() ([]byte, []int) {
-	return fileDescriptor_relay_9047ae8d90541176, []int{19}
+	return fileDescriptor_relay_1037c107938271b1, []int{19}
 }
 func (m *QueryRelayOrderParam) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_QueryRelayOrderParam.Unmarshal(m, b)
@@ -1793,7 +1841,7 @@ func (m *QueryRelayOrderResult) Reset()         { *m = QueryRelayOrderResult{} }
 func (m *QueryRelayOrderResult) String() string { return proto.CompactTextString(m) }
 func (*QueryRelayOrderResult) ProtoMessage()    {}
 func (*QueryRelayOrderResult) Descriptor() ([]byte, []int) {
-	return fileDescriptor_relay_9047ae8d90541176, []int{20}
+	return fileDescriptor_relay_1037c107938271b1, []int{20}
 }
 func (m *QueryRelayOrderResult) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_QueryRelayOrderResult.Unmarshal(m, b)
@@ -1833,7 +1881,7 @@ func (m *ReqRelayBtcHeaderHeightList) Reset()         { *m = ReqRelayBtcHeaderHe
 func (m *ReqRelayBtcHeaderHeightList) String() string { return proto.CompactTextString(m) }
 func (*ReqRelayBtcHeaderHeightList) ProtoMessage()    {}
 func (*ReqRelayBtcHeaderHeightList) Descriptor() ([]byte, []int) {
-	return fileDescriptor_relay_9047ae8d90541176, []int{21}
+	return fileDescriptor_relay_1037c107938271b1, []int{21}
 }
 func (m *ReqRelayBtcHeaderHeightList) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ReqRelayBtcHeaderHeightList.Unmarshal(m, b)
@@ -1885,7 +1933,7 @@ func (m *ReplyRelayBtcHeadHeightList) Reset()         { *m = ReplyRelayBtcHeadHe
 func (m *ReplyRelayBtcHeadHeightList) String() string { return proto.CompactTextString(m) }
 func (*ReplyRelayBtcHeadHeightList) ProtoMessage()    {}
 func (*ReplyRelayBtcHeadHeightList) Descriptor() ([]byte, []int) {
-	return fileDescriptor_relay_9047ae8d90541176, []int{22}
+	return fileDescriptor_relay_1037c107938271b1, []int{22}
 }
 func (m *ReplyRelayBtcHeadHeightList) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ReplyRelayBtcHeadHeightList.Unmarshal(m, b)
@@ -1923,7 +1971,7 @@ func (m *ReqRelayQryBTCHeadHeight) Reset()         { *m = ReqRelayQryBTCHeadHeig
 func (m *ReqRelayQryBTCHeadHeight) String() string { return proto.CompactTextString(m) }
 func (*ReqRelayQryBTCHeadHeight) ProtoMessage()    {}
 func (*ReqRelayQryBTCHeadHeight) Descriptor() ([]byte, []int) {
-	return fileDescriptor_relay_9047ae8d90541176, []int{23}
+	return fileDescriptor_relay_1037c107938271b1, []int{23}
 }
 func (m *ReqRelayQryBTCHeadHeight) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ReqRelayQryBTCHeadHeight.Unmarshal(m, b)
@@ -1962,7 +2010,7 @@ func (m *ReplayRelayQryBTCHeadHeight) Reset()         { *m = ReplayRelayQryBTCHe
 func (m *ReplayRelayQryBTCHeadHeight) String() string { return proto.CompactTextString(m) }
 func (*ReplayRelayQryBTCHeadHeight) ProtoMessage()    {}
 func (*ReplayRelayQryBTCHeadHeight) Descriptor() ([]byte, []int) {
-	return fileDescriptor_relay_9047ae8d90541176, []int{24}
+	return fileDescriptor_relay_1037c107938271b1, []int{24}
 }
 func (m *ReplayRelayQryBTCHeadHeight) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ReplayRelayQryBTCHeadHeight.Unmarshal(m, b)
@@ -2025,101 +2073,104 @@ func init() {
 	proto.RegisterEnum("types.RelayOrderStatus", RelayOrderStatus_name, RelayOrderStatus_value)
 }
 
-func init() { proto.RegisterFile("relay.proto", fileDescriptor_relay_9047ae8d90541176) }
-
-var fileDescriptor_relay_9047ae8d90541176 = []byte{
-	// 1487 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x58, 0xcf, 0x6e, 0xdb, 0x46,
-	0x13, 0x37, 0xc5, 0x3f, 0x96, 0x46, 0xb6, 0x23, 0xef, 0x17, 0xe7, 0xe3, 0x97, 0x2f, 0x68, 0x04,
-	0xa2, 0x2d, 0xdc, 0xa0, 0x70, 0x81, 0x04, 0x41, 0x81, 0xa2, 0x17, 0xcb, 0x87, 0x2a, 0x40, 0xd0,
-	0x24, 0x1b, 0xc3, 0x39, 0xf4, 0x44, 0x93, 0x6b, 0x6b, 0x11, 0x99, 0x54, 0xc8, 0x95, 0x22, 0xf5,
-	0xd6, 0xb7, 0xe8, 0xb9, 0x97, 0x02, 0x7d, 0x89, 0x3c, 0x42, 0x0f, 0x7d, 0x91, 0x3e, 0x42, 0x31,
-	0xb3, 0x4b, 0x72, 0x29, 0x39, 0x4e, 0x9b, 0x73, 0x4f, 0xe6, 0xcc, 0xfc, 0x76, 0x67, 0x38, 0x7f,
-	0x7e, 0x1c, 0x19, 0xfa, 0x85, 0x98, 0xc6, 0xab, 0xa3, 0x59, 0x91, 0xab, 0x9c, 0xf9, 0x6a, 0x35,
-	0x13, 0x65, 0xf4, 0x93, 0x0b, 0x7d, 0x8e, 0xea, 0xe3, 0x44, 0xc9, 0x3c, 0x63, 0x5f, 0x42, 0x90,
-	0x14, 0x22, 0x56, 0x22, 0x74, 0x86, 0xce, 0x61, 0xff, 0x21, 0x3b, 0x22, 0xdc, 0x11, 0x61, 0x4e,
-	0xc8, 0x32, 0xde, 0xe2, 0x06, 0x83, 0xe8, 0x38, 0x49, 0xc4, 0x4c, 0x85, 0x9d, 0x4d, 0xf4, 0x31,
-	0x59, 0x10, 0xad, 0x31, 0x88, 0x2e, 0xc4, 0x22, 0x7f, 0x2d, 0x42, 0x77, 0x13, 0xcd, 0xc9, 0x82,
-	0x68, 0x8d, 0x61, 0x8f, 0xa1, 0x97, 0xe4, 0xd9, 0x85, 0x2c, 0xae, 0x4e, 0x97, 0xa1, 0x47, 0x07,
-	0x0e, 0x5a, 0xc1, 0x54, 0xc6, 0xf1, 0x16, 0x6f, 0x90, 0xe8, 0x64, 0x21, 0x0a, 0x79, 0xb1, 0x0a,
-	0xfd, 0x4d, 0x27, 0x67, 0x64, 0x41, 0x27, 0x1a, 0x83, 0x4e, 0xf4, 0xd3, 0xc9, 0x54, 0x86, 0xc1,
-	0xa6, 0x93, 0xb3, 0xca, 0x88, 0x4e, 0x6a, 0x24, 0x7b, 0x04, 0x70, 0xae, 0x92, 0xb1, 0x88, 0x53,
-	0x51, 0x94, 0xe1, 0x36, 0x9d, 0xdb, 0x37, 0xe7, 0x46, 0xb5, 0x61, 0xbc, 0xc5, 0x2d, 0x18, 0xdb,
-	0x83, 0x8e, 0x5a, 0x85, 0x30, 0x74, 0x0e, 0x7d, 0xde, 0x51, 0xab, 0xd1, 0x36, 0xf8, 0x8b, 0x78,
-	0x3a, 0x17, 0xd1, 0x9f, 0x1e, 0x00, 0x79, 0x7b, 0x56, 0xa4, 0xa2, 0x40, 0x9c, 0x4c, 0x29, 0xfd,
-	0x3d, 0xde, 0x91, 0x29, 0xfb, 0x0a, 0x82, 0x52, 0xc5, 0x6a, 0x5e, 0x52, 0x92, 0xf7, 0x1e, 0xfe,
-	0xd7, 0x0e, 0x90, 0x8e, 0xbc, 0x24, 0x33, 0x37, 0x30, 0x7c, 0xa9, 0x59, 0x21, 0xb4, 0x92, 0x52,
-	0x7d, 0xc3, 0x99, 0x06, 0xc9, 0xee, 0x40, 0x10, 0x5f, 0xe5, 0xf3, 0x4c, 0x51, 0xb6, 0x3d, 0x6e,
-	0x24, 0x36, 0x84, 0xbe, 0x2e, 0x77, 0x71, 0x9c, 0xa6, 0x05, 0xa5, 0xb5, 0xc7, 0x6d, 0x15, 0xfb,
-	0x14, 0x76, 0x93, 0x5c, 0x66, 0xcf, 0x66, 0xa2, 0x88, 0xb1, 0x8b, 0x28, 0x93, 0xbb, 0xbc, 0xad,
-	0x64, 0x0c, 0x3c, 0x54, 0x50, 0xba, 0x7a, 0x9c, 0x9e, 0xd9, 0x27, 0x00, 0xf8, 0xf7, 0x58, 0xfb,
-	0xed, 0x92, 0x5f, 0x4b, 0xc3, 0xee, 0x42, 0x97, 0x24, 0x74, 0xdc, 0xa3, 0x73, 0xb5, 0x5c, 0x9d,
-	0x3d, 0x5d, 0x8e, 0xe3, 0x72, 0x42, 0x79, 0xed, 0x71, 0x4b, 0x43, 0x76, 0x0a, 0xf2, 0x54, 0x5e,
-	0x89, 0xb0, 0x3f, 0x74, 0x0e, 0x5d, 0x6e, 0x69, 0xd0, 0xae, 0x1b, 0x93, 0x6e, 0xdf, 0xd1, 0xe7,
-	0x1b, 0x4d, 0x63, 0xa7, 0xf3, 0xbb, 0xfa, 0x7c, 0xa3, 0xa1, 0xbc, 0x98, 0xb6, 0x43, 0xc0, 0x1e,
-	0x01, 0x6c, 0x15, 0xde, 0x70, 0x21, 0x33, 0x59, 0x4e, 0x08, 0x70, 0x4b, 0xdf, 0xd0, 0x68, 0x58,
-	0x04, 0x3b, 0x46, 0xd2, 0xef, 0x30, 0xa0, 0x18, 0x5a, 0x3a, 0xac, 0xca, 0x44, 0xc8, 0xcb, 0x89,
-	0x0a, 0xf7, 0xe9, 0xbc, 0x91, 0xaa, 0xb7, 0x1f, 0x6b, 0x1b, 0x6b, 0x32, 0xa7, 0x35, 0xec, 0x1e,
-	0x8e, 0x8f, 0xcc, 0x5e, 0xc5, 0x52, 0x95, 0xe1, 0x7f, 0xa8, 0x1e, 0x8d, 0x22, 0xfa, 0xd5, 0x31,
-	0x63, 0xaf, 0x47, 0x1a, 0xd1, 0x79, 0x5d, 0x3d, 0x47, 0xa3, 0xf3, 0x8d, 0xca, 0x75, 0xac, 0xca,
-	0x35, 0xdd, 0xe2, 0xb6, 0xba, 0x85, 0x81, 0x17, 0x63, 0x3e, 0x3d, 0x8d, 0xc5, 0x67, 0xbc, 0xfd,
-	0x5c, 0xad, 0x4c, 0x91, 0x7d, 0x82, 0x37, 0x8a, 0x76, 0xa4, 0xc1, 0x7a, 0xa4, 0x71, 0xcd, 0x4f,
-	0xc4, 0x21, 0x21, 0x6c, 0xe7, 0xd8, 0xbe, 0x4f, 0xaa, 0x09, 0xa9, 0xc4, 0x56, 0xab, 0x74, 0xd6,
-	0x5a, 0xa5, 0xe5, 0xc2, 0x5d, 0x77, 0xf1, 0xca, 0xb8, 0xd0, 0x14, 0x74, 0x83, 0x8b, 0x3b, 0x10,
-	0xa8, 0xb8, 0xb8, 0x14, 0x9a, 0xee, 0x76, 0xb9, 0x91, 0x28, 0x17, 0x44, 0x9f, 0xe6, 0x6e, 0x23,
-	0x45, 0x23, 0xd8, 0x6b, 0x53, 0xd5, 0x07, 0xee, 0xd6, 0x5d, 0xa0, 0x83, 0x37, 0x52, 0x94, 0x9b,
-	0xe0, 0x34, 0x13, 0xdd, 0x70, 0xc1, 0x67, 0xd0, 0x51, 0x4b, 0xc3, 0xc3, 0x07, 0x0d, 0x17, 0x9d,
-	0x16, 0x71, 0x56, 0xea, 0x78, 0x78, 0x47, 0x2d, 0xd9, 0x7d, 0x70, 0xcb, 0xd9, 0xc2, 0x30, 0xf0,
-	0x6e, 0x83, 0x7b, 0x39, 0x5b, 0x70, 0xb4, 0x44, 0x3f, 0x3b, 0x26, 0xea, 0x9a, 0xfb, 0x6e, 0x70,
-	0x7a, 0x1b, 0xfc, 0x22, 0x7e, 0x7b, 0xba, 0x34, 0x41, 0x6b, 0x01, 0xf1, 0x6a, 0xf9, 0x24, 0x4b,
-	0xc5, 0xd2, 0x24, 0xa4, 0x12, 0xb1, 0x6b, 0xaf, 0x44, 0xf1, 0x7a, 0x54, 0xc4, 0x59, 0x32, 0x31,
-	0x3d, 0x62, 0x69, 0xa8, 0x53, 0xa6, 0x79, 0xf2, 0x9a, 0x12, 0xa1, 0x99, 0xa6, 0x51, 0x44, 0xbf,
-	0x77, 0xa0, 0x57, 0xd3, 0x2b, 0x76, 0xda, 0x04, 0x61, 0x3a, 0x24, 0x7a, 0xd6, 0x4c, 0x44, 0xc9,
-	0xa6, 0xce, 0xd5, 0x94, 0xe9, 0xf1, 0xb6, 0xd2, 0x9a, 0x29, 0xd3, 0xbb, 0x66, 0xa6, 0x42, 0xd8,
-	0x5e, 0x88, 0xa2, 0xc4, 0x42, 0x7a, 0x3a, 0x6e, 0x23, 0x56, 0x71, 0x4f, 0x05, 0xcf, 0x73, 0x65,
-	0x02, 0xb3, 0x34, 0x18, 0x8b, 0xc2, 0x19, 0x0f, 0x68, 0x46, 0xe9, 0x19, 0x73, 0x93, 0xe5, 0x59,
-	0x22, 0x88, 0xf0, 0x3c, 0xae, 0x05, 0x44, 0x9e, 0x63, 0x17, 0x76, 0x35, 0x12, 0x9f, 0xf1, 0xf6,
-	0x54, 0x5e, 0x5c, 0xc8, 0x64, 0x3e, 0x55, 0x2b, 0xe2, 0x39, 0x97, 0x5b, 0x1a, 0xe4, 0x89, 0x59,
-	0x21, 0x16, 0x32, 0x9f, 0x97, 0x16, 0xd7, 0xb5, 0x74, 0xd8, 0xfe, 0x99, 0x58, 0x2a, 0xb2, 0xf7,
-	0x75, 0xfb, 0x57, 0x32, 0xbe, 0x97, 0x2c, 0xb9, 0x28, 0x85, 0x22, 0x9a, 0xeb, 0xf2, 0x4a, 0x8c,
-	0xbe, 0x05, 0x68, 0xbe, 0x57, 0xec, 0x08, 0xe7, 0xd4, 0x48, 0xa1, 0x33, 0x74, 0x0f, 0xfb, 0x0f,
-	0x07, 0xeb, 0x5f, 0x35, 0xde, 0x40, 0xa2, 0x77, 0x0e, 0xec, 0xb5, 0x5b, 0xec, 0xda, 0xa2, 0x0c,
-	0xa1, 0xaf, 0x6b, 0xa8, 0x73, 0xae, 0x4b, 0x62, 0xab, 0xd8, 0x3d, 0x70, 0x17, 0x12, 0xa7, 0x07,
-	0x5d, 0x82, 0x71, 0x79, 0x26, 0x33, 0x8e, 0x6a, 0x76, 0x1f, 0xbc, 0x45, 0x3e, 0xc7, 0xcf, 0x12,
-	0x9a, 0xfb, 0x95, 0x39, 0x9f, 0x2b, 0x4e, 0x86, 0x3a, 0xfb, 0xbe, 0x95, 0xfd, 0x8d, 0x4e, 0x08,
-	0xae, 0xe9, 0x84, 0xe8, 0x31, 0xb8, 0x67, 0x32, 0xc3, 0x04, 0x21, 0x51, 0x89, 0xb2, 0xac, 0x1a,
-	0xdc, 0x88, 0x58, 0xc4, 0x33, 0xfc, 0x48, 0x9b, 0xa8, 0xb5, 0x10, 0x71, 0xf0, 0xd0, 0x7d, 0xc5,
-	0x39, 0xe7, 0x71, 0xa9, 0xf7, 0xa5, 0x2e, 0xaf, 0x65, 0xfb, 0xce, 0xce, 0x7b, 0xee, 0x74, 0xed,
-	0x3b, 0x7f, 0x71, 0x20, 0xd0, 0x73, 0x78, 0x6d, 0x12, 0xab, 0x77, 0xec, 0x58, 0xef, 0xf8, 0xbe,
-	0x3e, 0x6e, 0x4d, 0x91, 0xb7, 0x36, 0x45, 0xf6, 0x74, 0xfa, 0xed, 0xe9, 0xc4, 0x42, 0xd1, 0x1c,
-	0x3e, 0x2f, 0xf2, 0xfc, 0x22, 0x0c, 0x86, 0xee, 0xe1, 0x0e, 0xb7, 0x55, 0x51, 0x0c, 0x07, 0xc4,
-	0x0d, 0x4f, 0xe3, 0x52, 0xf1, 0x64, 0xd1, 0x0c, 0xe3, 0x21, 0x04, 0x75, 0xdf, 0x38, 0xd7, 0xf6,
-	0x8d, 0xb1, 0x63, 0xb3, 0x63, 0x7e, 0x5a, 0xcd, 0x60, 0x69, 0xa2, 0x3f, 0x1c, 0xf8, 0x1f, 0x17,
-	0x89, 0x90, 0x33, 0xa5, 0x59, 0x39, 0x59, 0x8c, 0x4e, 0x4f, 0xaa, 0x16, 0x7d, 0x00, 0xdb, 0x13,
-	0xb3, 0x76, 0xbd, 0xaf, 0x41, 0x2b, 0x00, 0x7a, 0x9a, 0xc6, 0xa5, 0x6a, 0x7b, 0x6a, 0x34, 0x98,
-	0xa6, 0x4c, 0xbc, 0x1d, 0xdb, 0x19, 0x6c, 0x14, 0xec, 0x73, 0xd8, 0x43, 0xec, 0xa8, 0x89, 0x55,
-	0xaf, 0x45, 0x6b, 0x5a, 0x6c, 0xb4, 0x4c, 0xbc, 0xb5, 0x60, 0xfa, 0x03, 0xd7, 0x56, 0x46, 0xef,
-	0x3c, 0xb8, 0x65, 0xbf, 0xd5, 0xd3, 0xfc, 0xf2, 0x06, 0x5a, 0xc5, 0xef, 0xd5, 0xdc, 0xac, 0x68,
-	0xa6, 0x7b, 0x1a, 0x05, 0x5a, 0xdb, 0xfb, 0x5d, 0xcf, 0x5e, 0xe3, 0xee, 0x42, 0x57, 0x2d, 0x8f,
-	0x9b, 0x45, 0xae, 0xc7, 0x6b, 0xf9, 0x63, 0x57, 0xb9, 0xde, 0xc7, 0xad, 0x72, 0xbd, 0x7f, 0x57,
-	0xb9, 0xd6, 0x2a, 0xd7, 0x5e, 0xd9, 0xf6, 0x6f, 0x5e, 0xd9, 0xd8, 0xfa, 0x96, 0xf2, 0x9b, 0x03,
-	0xfb, 0x5c, 0xbc, 0xd1, 0xcb, 0x50, 0x9a, 0x16, 0x27, 0xb9, 0xcc, 0xca, 0x7a, 0xdd, 0x72, 0xac,
-	0x75, 0xeb, 0x1f, 0xff, 0x60, 0xb8, 0x0d, 0x3e, 0xfa, 0x29, 0x89, 0x80, 0x7b, 0x5c, 0x0b, 0x18,
-	0xee, 0x2c, 0xbe, 0x14, 0xdf, 0xcf, 0xaf, 0xce, 0x85, 0xde, 0xe7, 0x7c, 0x6e, 0x69, 0xb0, 0xa0,
-	0x28, 0xbd, 0x94, 0x3f, 0x6a, 0xe6, 0xf5, 0x79, 0x2d, 0x47, 0xdf, 0xc1, 0x80, 0x8b, 0xd9, 0x74,
-	0xd5, 0xb8, 0x2c, 0xd9, 0x23, 0xf3, 0x03, 0x94, 0x9a, 0xbc, 0x1a, 0xdf, 0xfd, 0x8d, 0xd8, 0xb8,
-	0x8d, 0x8a, 0x62, 0xb8, 0xfd, 0x62, 0x2e, 0x0a, 0xeb, 0xa2, 0xe7, 0x71, 0x11, 0x5f, 0x59, 0xef,
-	0xe8, 0xfc, 0xbd, 0x77, 0xb4, 0x86, 0xad, 0xd3, 0x1a, 0xb6, 0x68, 0x04, 0x07, 0x6b, 0x2e, 0xb8,
-	0x28, 0xe7, 0x53, 0xc5, 0xbe, 0x80, 0xe0, 0x43, 0xb1, 0x1a, 0x40, 0xf4, 0x06, 0xfe, 0x5f, 0xd5,
-	0xa6, 0x26, 0x22, 0x5d, 0xd5, 0xa7, 0xb2, 0xa4, 0xca, 0x16, 0xe2, 0x8d, 0x29, 0xbc, 0x43, 0xcd,
-	0xd3, 0x28, 0x90, 0xc6, 0x13, 0x1c, 0x11, 0x5d, 0x2f, 0x9f, 0x1b, 0x09, 0x4f, 0xa5, 0xb2, 0x10,
-	0xcd, 0x66, 0xe9, 0xf3, 0x46, 0x11, 0x7d, 0x8d, 0x2e, 0xab, 0x14, 0x1b, 0xa7, 0x96, 0xcb, 0x10,
-	0x89, 0x12, 0x25, 0x1d, 0xbd, 0xcb, 0x2b, 0x31, 0xfa, 0x06, 0xc2, 0x2a, 0xd6, 0x17, 0xc5, 0xca,
-	0x70, 0xeb, 0xb8, 0xfe, 0x55, 0x61, 0x91, 0xb3, 0x8e, 0xd4, 0x26, 0xe7, 0x1f, 0xb4, 0xd3, 0x78,
-	0x75, 0xfd, 0x71, 0xcd, 0x5b, 0xed, 0xf7, 0xac, 0x15, 0xd7, 0x30, 0x7f, 0xeb, 0xf2, 0x07, 0x39,
-	0x36, 0x4d, 0xbb, 0x7c, 0xac, 0x0b, 0x9e, 0xcc, 0xa4, 0x1a, 0x6c, 0xb1, 0x3e, 0x6c, 0xcf, 0x44,
-	0x96, 0xca, 0xec, 0x72, 0xe0, 0xa0, 0x80, 0xdf, 0x33, 0x14, 0x3a, 0x6c, 0x0f, 0xe7, 0x8a, 0x46,
-	0x15, 0x65, 0x97, 0xed, 0x40, 0x57, 0xcf, 0x9d, 0x48, 0x07, 0x1e, 0x4a, 0x49, 0x9c, 0x25, 0x62,
-	0x2a, 0xd2, 0x81, 0x8f, 0x07, 0xf1, 0xd3, 0x99, 0xcf, 0xd5, 0x20, 0x38, 0x0f, 0xe8, 0x5f, 0x21,
-	0x8f, 0xfe, 0x0a, 0x00, 0x00, 0xff, 0xff, 0x78, 0x69, 0x6c, 0x7c, 0x19, 0x11, 0x00, 0x00,
+func init() { proto.RegisterFile("relay.proto", fileDescriptor_relay_1037c107938271b1) }
+
+var fileDescriptor_relay_1037c107938271b1 = []byte{
+	// 1524 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x58, 0xc1, 0x6e, 0xdb, 0x46,
+	0x13, 0x36, 0x25, 0x91, 0x16, 0x47, 0xb6, 0x23, 0x6f, 0xec, 0xfc, 0xfc, 0xdb, 0xa0, 0x31, 0x88,
+	0xb6, 0x70, 0x83, 0xc2, 0x05, 0x12, 0x04, 0x05, 0x8a, 0x5e, 0x2c, 0xa3, 0xa8, 0x02, 0x04, 0x4d,
+	0xb2, 0x36, 0x9c, 0x02, 0x3d, 0x14, 0x34, 0xb9, 0xb6, 0x89, 0xc8, 0xa4, 0xb2, 0x5c, 0x29, 0x52,
+	0x6f, 0x3d, 0x17, 0xbd, 0xf7, 0xdc, 0x63, 0x9f, 0xa0, 0xb7, 0x3e, 0x42, 0x0f, 0x7d, 0xa1, 0x62,
+	0x66, 0x97, 0xe4, 0x52, 0x96, 0x1d, 0xb5, 0xd7, 0xde, 0x38, 0x33, 0xdf, 0xee, 0xcc, 0xce, 0xce,
+	0x7c, 0x3b, 0x12, 0xf4, 0xa4, 0x18, 0x45, 0xf3, 0x83, 0xb1, 0xcc, 0x55, 0xce, 0x5c, 0x35, 0x1f,
+	0x8b, 0x22, 0xfc, 0xb1, 0x0d, 0x3d, 0x8e, 0xea, 0xc3, 0x58, 0xa5, 0x79, 0xc6, 0x3e, 0x05, 0x2f,
+	0x96, 0x22, 0x52, 0x22, 0x70, 0xf6, 0x9c, 0xfd, 0xde, 0x23, 0x76, 0x40, 0xb8, 0x03, 0xc2, 0x1c,
+	0x91, 0x65, 0xb8, 0xc6, 0x0d, 0x06, 0xd1, 0x51, 0x1c, 0x8b, 0xb1, 0x0a, 0x5a, 0xd7, 0xd1, 0x87,
+	0x64, 0x41, 0xb4, 0xc6, 0x20, 0x5a, 0x8a, 0x69, 0xfe, 0x5a, 0x04, 0xed, 0xeb, 0x68, 0x4e, 0x16,
+	0x44, 0x6b, 0x0c, 0x7b, 0x02, 0x7e, 0x9c, 0x67, 0xe7, 0xa9, 0xbc, 0x3a, 0x99, 0x05, 0x1d, 0x5a,
+	0xb0, 0xdb, 0x08, 0xa6, 0x34, 0x0e, 0xd7, 0x78, 0x8d, 0x44, 0x27, 0x53, 0x21, 0xd3, 0xf3, 0x79,
+	0xe0, 0x5e, 0x77, 0x72, 0x4a, 0x16, 0x74, 0xa2, 0x31, 0xe8, 0x44, 0x7f, 0x1d, 0x8d, 0xd2, 0xc0,
+	0xbb, 0xee, 0xe4, 0xb4, 0x34, 0xa2, 0x93, 0x0a, 0xc9, 0x1e, 0x03, 0x9c, 0xa9, 0x78, 0x28, 0xa2,
+	0x44, 0xc8, 0x22, 0x58, 0xa7, 0x75, 0xdb, 0x66, 0xdd, 0xa0, 0x32, 0x0c, 0xd7, 0xb8, 0x05, 0x63,
+	0x5b, 0xd0, 0x52, 0xf3, 0x00, 0xf6, 0x9c, 0x7d, 0x97, 0xb7, 0xd4, 0x7c, 0xb0, 0x0e, 0xee, 0x34,
+	0x1a, 0x4d, 0x44, 0xf8, 0xbb, 0x0b, 0x40, 0xde, 0x9e, 0xcb, 0x44, 0x48, 0xc4, 0xa5, 0x09, 0xa5,
+	0xdf, 0xe7, 0xad, 0x34, 0x61, 0x9f, 0x81, 0x57, 0xa8, 0x48, 0x4d, 0x0a, 0x4a, 0xf2, 0xd6, 0xa3,
+	0xff, 0xd9, 0x01, 0xd2, 0x92, 0x63, 0x32, 0x73, 0x03, 0xc3, 0x43, 0x8d, 0xa5, 0xd0, 0x4a, 0x4a,
+	0xf5, 0x2d, 0x6b, 0x6a, 0x24, 0xdb, 0x87, 0x3b, 0xa3, 0x3c, 0x8e, 0x46, 0x47, 0x79, 0x9a, 0x1d,
+	0x5e, 0xe5, 0x93, 0x4c, 0x51, 0xda, 0x3b, 0x7c, 0x51, 0xcd, 0xf6, 0xa0, 0xa7, 0x0b, 0x40, 0x1e,
+	0x26, 0x89, 0xa4, 0x44, 0xfb, 0xdc, 0x56, 0xb1, 0xfb, 0xe0, 0xe7, 0x63, 0x21, 0x23, 0xac, 0x29,
+	0xca, 0xeb, 0x26, 0xaf, 0x15, 0x6c, 0x07, 0xdc, 0x19, 0x6e, 0x47, 0x99, 0xf3, 0xb9, 0x16, 0x58,
+	0x00, 0xeb, 0x33, 0xe3, 0xb7, 0x4b, 0x7e, 0x4b, 0x91, 0xf0, 0xe4, 0xc9, 0x37, 0x78, 0xf2, 0x81,
+	0xf8, 0x93, 0xd9, 0x30, 0x2a, 0x2e, 0x29, 0xa9, 0x3e, 0x2f, 0x45, 0xf6, 0x01, 0x80, 0x0e, 0xe6,
+	0x24, 0xbd, 0x12, 0x41, 0x6f, 0xcf, 0xd9, 0x6f, 0x73, 0x4b, 0x83, 0x76, 0x5d, 0x92, 0xb4, 0xe9,
+	0x06, 0x2d, 0xb6, 0x34, 0xb5, 0x9d, 0xd6, 0x6f, 0xea, 0xf5, 0xb5, 0x86, 0xce, 0x6f, 0x0a, 0x0e,
+	0x01, 0x5b, 0x04, 0xb0, 0x55, 0xb8, 0xc3, 0x79, 0x9a, 0xa5, 0xc5, 0x25, 0x01, 0xee, 0xe8, 0x1d,
+	0x6a, 0x0d, 0x0b, 0x61, 0xc3, 0x48, 0xfa, 0x00, 0x7d, 0x8a, 0xa1, 0xa1, 0x63, 0xf7, 0xc0, 0xbb,
+	0x14, 0xe9, 0xc5, 0xa5, 0x0a, 0xb6, 0x69, 0xbd, 0x91, 0xf0, 0xdc, 0xdf, 0x0e, 0xb5, 0x81, 0xe9,
+	0x3c, 0x19, 0x11, 0xe3, 0x9a, 0x0d, 0x46, 0x79, 0xfc, 0xfa, 0x55, 0x94, 0xaa, 0x22, 0xb8, 0x4b,
+	0x79, 0xb7, 0x55, 0x8d, 0x3b, 0x3e, 0x9e, 0x5f, 0x9d, 0xe5, 0xa3, 0x60, 0x87, 0x5c, 0x2f, 0xaa,
+	0xd9, 0x87, 0xb0, 0x59, 0xa9, 0xbe, 0x9a, 0x89, 0x38, 0xd8, 0x25, 0x5c, 0x53, 0x19, 0xfe, 0xdc,
+	0x32, 0xf4, 0xa1, 0xa9, 0xa1, 0x79, 0xef, 0xce, 0x8d, 0xf7, 0xde, 0xba, 0xe1, 0xde, 0xdb, 0x37,
+	0xdc, 0x7b, 0xc7, 0xbe, 0xf7, 0x25, 0x75, 0xea, 0xde, 0x58, 0xa7, 0x76, 0x3e, 0xbc, 0x95, 0xf2,
+	0xb1, 0xbe, 0x62, 0x3e, 0xba, 0xcb, 0xf2, 0xf1, 0x7d, 0xc5, 0xa6, 0xc4, 0x78, 0x01, 0xac, 0xe7,
+	0xd8, 0x6c, 0x4f, 0xcb, 0x7e, 0x2e, 0xc5, 0xfa, 0x68, 0x2d, 0xfb, 0x68, 0x0b, 0x01, 0xb7, 0xaf,
+	0x05, 0x1c, 0xbe, 0x32, 0x0e, 0x34, 0x5d, 0xde, 0xe2, 0xe0, 0x1e, 0x78, 0x2a, 0x92, 0x17, 0x42,
+	0x53, 0xf3, 0x26, 0x37, 0x12, 0xea, 0x23, 0xa2, 0x7a, 0xb3, 0xbb, 0x91, 0xc2, 0x01, 0x6c, 0x35,
+	0x69, 0xf5, 0x1d, 0x7b, 0xeb, 0xba, 0xd5, 0xd1, 0x1b, 0x29, 0xcc, 0x4d, 0x70, 0x9a, 0x35, 0x6f,
+	0xd9, 0xe0, 0x23, 0x68, 0xa9, 0x99, 0x79, 0x33, 0x76, 0x6b, 0xde, 0x3c, 0x91, 0x51, 0x56, 0xe8,
+	0x78, 0x78, 0x4b, 0xcd, 0xd8, 0x03, 0x68, 0x17, 0xe3, 0xa9, 0x79, 0x2d, 0x36, 0x6b, 0xdc, 0xf1,
+	0x78, 0xca, 0xd1, 0x12, 0xfe, 0xe2, 0x98, 0xa8, 0x2b, 0x9e, 0xbe, 0x3d, 0xe5, 0x32, 0x7a, 0x7b,
+	0x32, 0x2b, 0x53, 0x4e, 0x02, 0xe2, 0xd5, 0xec, 0x69, 0x96, 0x88, 0x99, 0x49, 0x48, 0x29, 0x62,
+	0x0f, 0x5f, 0x09, 0xf9, 0x7a, 0x20, 0xa3, 0x2c, 0xbe, 0x34, 0x25, 0x68, 0x69, 0xb0, 0xd6, 0xcf,
+	0xf0, 0x62, 0x28, 0x11, 0x9a, 0x03, 0x6b, 0x45, 0xf8, 0x67, 0x0b, 0xfc, 0xea, 0x29, 0x60, 0x0c,
+	0x3a, 0x97, 0x08, 0xd3, 0x21, 0xd1, 0x37, 0x56, 0x94, 0xa1, 0x0c, 0xea, 0x0e, 0x4d, 0xef, 0x1d,
+	0xde, 0x54, 0x5a, 0x2c, 0xa0, 0x9b, 0xc3, 0x62, 0x81, 0xa9, 0x90, 0x05, 0x5e, 0x64, 0x47, 0xc7,
+	0x6d, 0xc4, 0x32, 0xee, 0x91, 0xe0, 0x79, 0xae, 0x4c, 0x60, 0x96, 0x06, 0x63, 0x51, 0xc8, 0x4a,
+	0x1e, 0xb1, 0x0a, 0x7d, 0x63, 0x6e, 0xb2, 0x3c, 0x8b, 0x05, 0x55, 0x7f, 0x87, 0x6b, 0x01, 0x91,
+	0x67, 0x58, 0x87, 0x5d, 0x8d, 0xc4, 0x6f, 0xdc, 0x3d, 0x49, 0xcf, 0xcf, 0xd3, 0x78, 0x32, 0x52,
+	0x73, 0x22, 0xe4, 0x36, 0xb7, 0x34, 0xc8, 0x6c, 0x63, 0x29, 0xa6, 0x69, 0x3e, 0x29, 0x2c, 0x6a,
+	0x6e, 0xe8, 0xd8, 0x7b, 0xd0, 0xcd, 0xc4, 0x4c, 0x91, 0xbd, 0x47, 0xf6, 0x4a, 0xc6, 0x73, 0xa5,
+	0x05, 0x17, 0x85, 0x50, 0x44, 0xcc, 0x5d, 0x5e, 0x8a, 0xe1, 0x97, 0x00, 0xf5, 0xdb, 0xca, 0x0e,
+	0xc0, 0xaf, 0xde, 0xd6, 0xc0, 0xd9, 0x6b, 0xef, 0xf7, 0x1e, 0xf5, 0x17, 0x5f, 0x60, 0x5e, 0x43,
+	0xc2, 0x3f, 0x1c, 0xd8, 0x6a, 0x96, 0xd8, 0xd2, 0x4b, 0xd9, 0x83, 0x9e, 0xbe, 0x43, 0x9d, 0x73,
+	0x7d, 0x25, 0xb6, 0x8a, 0xdd, 0x87, 0xf6, 0x34, 0xc5, 0xee, 0x41, 0x97, 0x60, 0x5c, 0x9e, 0xa6,
+	0x19, 0x47, 0x35, 0x7b, 0x00, 0x9d, 0x69, 0x3e, 0xc1, 0x97, 0x13, 0xcd, 0xbd, 0xd2, 0x9c, 0x4f,
+	0x14, 0x27, 0x43, 0x95, 0x7d, 0xd7, 0xca, 0xfe, 0xb5, 0x4a, 0xf0, 0x96, 0x54, 0x42, 0xf8, 0x04,
+	0xda, 0xa7, 0x9a, 0x2e, 0xa3, 0x24, 0x91, 0xa2, 0x28, 0xca, 0x02, 0x37, 0x22, 0x5e, 0xe2, 0x29,
+	0x0e, 0x14, 0x26, 0x6a, 0x2d, 0x84, 0x1c, 0x3a, 0xe8, 0x1e, 0x93, 0x1e, 0xe7, 0x69, 0x76, 0x16,
+	0x15, 0x7a, 0xb6, 0xeb, 0xf2, 0x4a, 0xb6, 0xf7, 0x6c, 0xdd, 0xb0, 0x67, 0xdb, 0xde, 0xf3, 0x57,
+	0x07, 0x3c, 0xdd, 0x87, 0x4b, 0x93, 0x58, 0x9e, 0xb1, 0x65, 0x9d, 0xf1, 0xa6, 0x3a, 0x6e, 0x74,
+	0x51, 0x67, 0xa1, 0x8b, 0xec, 0xee, 0x74, 0x9b, 0xdd, 0x89, 0x17, 0x45, 0x7d, 0xf8, 0x42, 0xe6,
+	0xf9, 0x79, 0xe0, 0xed, 0xb5, 0xf7, 0x37, 0xb8, 0xad, 0x0a, 0x23, 0xd8, 0x25, 0x6e, 0x78, 0x16,
+	0x15, 0x8a, 0xc7, 0xd3, 0xba, 0x19, 0xf7, 0xc1, 0xab, 0xea, 0xc6, 0x59, 0x5a, 0x37, 0xc6, 0x8e,
+	0xc5, 0x8e, 0xf9, 0x69, 0x14, 0x83, 0xa5, 0x09, 0xff, 0x72, 0xe0, 0xff, 0x5c, 0xc4, 0x22, 0x1d,
+	0x2b, 0xcd, 0xca, 0xf1, 0x74, 0x70, 0x72, 0x54, 0x96, 0xe8, 0x43, 0x58, 0xbf, 0x34, 0x23, 0xe2,
+	0x4d, 0x05, 0x5a, 0x02, 0xd0, 0xd3, 0x28, 0x2a, 0x54, 0xd3, 0x53, 0xad, 0xc1, 0x34, 0x65, 0xe2,
+	0xed, 0xd0, 0xce, 0x60, 0xad, 0x60, 0x1f, 0xc3, 0x16, 0x62, 0x07, 0x75, 0xac, 0x7a, 0x72, 0x5b,
+	0xd0, 0x62, 0xa1, 0x65, 0xe2, 0xad, 0x05, 0xd3, 0x0f, 0x67, 0x53, 0x19, 0xfe, 0xe4, 0xc2, 0x1d,
+	0xfb, 0x54, 0xcf, 0xf2, 0x8b, 0x5b, 0x68, 0xf5, 0x3e, 0xf8, 0xf1, 0xc4, 0x8c, 0x93, 0xa6, 0x7a,
+	0x6a, 0x05, 0x5a, 0x9b, 0xb3, 0xa8, 0xbf, 0xc2, 0xc8, 0xe9, 0xff, 0x9b, 0x91, 0x93, 0x9a, 0x28,
+	0xcd, 0x9e, 0x2f, 0x8c, 0x9d, 0x4d, 0xe5, 0x6a, 0xa3, 0xa7, 0xff, 0x5f, 0x1f, 0x3d, 0xf1, 0x7c,
+	0xc3, 0x7a, 0xf6, 0xc4, 0x91, 0x6c, 0xf9, 0x88, 0xc9, 0x56, 0x1a, 0xa9, 0xee, 0xae, 0x38, 0x52,
+	0xed, 0x2c, 0x1b, 0xa9, 0x7e, 0x73, 0x60, 0x9b, 0x8b, 0x37, 0x7a, 0xac, 0x4a, 0x12, 0x89, 0x86,
+	0x02, 0x29, 0x06, 0x29, 0xaa, 0xa4, 0x1d, 0xfc, 0xfe, 0xe7, 0x3f, 0x94, 0x76, 0xc0, 0xc5, 0xea,
+	0x28, 0x88, 0xcc, 0x7d, 0xae, 0x05, 0x4c, 0xe0, 0x38, 0xba, 0x10, 0xdf, 0x4c, 0xae, 0xce, 0x84,
+	0x1e, 0x3d, 0x5d, 0x6e, 0x69, 0x90, 0x48, 0x51, 0x3a, 0x4e, 0x7f, 0xd0, 0x2c, 0xee, 0xf2, 0x4a,
+	0x0e, 0xbf, 0x86, 0x3e, 0x17, 0xe3, 0xd1, 0xbc, 0x76, 0x59, 0xb0, 0xc7, 0xe6, 0x87, 0x37, 0x35,
+	0x4c, 0x49, 0x05, 0xdb, 0xd7, 0x62, 0xe3, 0x36, 0x2a, 0x8c, 0x60, 0xe7, 0xe5, 0x44, 0x48, 0x6b,
+	0xa3, 0x17, 0x91, 0x8c, 0xae, 0xac, 0x33, 0x3a, 0xab, 0x9d, 0xd1, 0x6a, 0xdc, 0x56, 0xa3, 0x71,
+	0xc3, 0x01, 0xec, 0x2e, 0xb8, 0xe0, 0xa2, 0x98, 0x8c, 0x14, 0xfb, 0x04, 0xbc, 0x77, 0xc5, 0x6a,
+	0x00, 0xe1, 0x1b, 0x78, 0xbf, 0xbc, 0x9b, 0x8a, 0xd4, 0x74, 0xa5, 0x3c, 0x4b, 0x0b, 0x62, 0x2d,
+	0x29, 0xde, 0x98, 0x4a, 0x72, 0xa8, 0x14, 0x6b, 0x05, 0x3e, 0x09, 0x31, 0x36, 0x99, 0xbe, 0x2f,
+	0x97, 0x1b, 0x09, 0x57, 0x25, 0xa9, 0x14, 0xf5, 0x94, 0xea, 0xf2, 0x5a, 0x11, 0x7e, 0x8e, 0x2e,
+	0xcb, 0x14, 0x1b, 0xa7, 0x96, 0xcb, 0x00, 0x49, 0x17, 0x25, 0x1d, 0x7d, 0x9b, 0x97, 0x62, 0xf8,
+	0x05, 0x04, 0x65, 0xac, 0x2f, 0xe5, 0xdc, 0xf0, 0xb4, 0x09, 0xa5, 0x49, 0xf4, 0x3a, 0x52, 0x9b,
+	0xe8, 0xbf, 0xd3, 0x4e, 0xa3, 0xf9, 0xf2, 0xe5, 0x9a, 0x03, 0x9b, 0xe7, 0xac, 0x14, 0x4b, 0x5e,
+	0x91, 0xc6, 0xe6, 0x0f, 0x73, 0x2c, 0x9a, 0xe6, 0xf5, 0xb1, 0x2e, 0x74, 0xd2, 0x2c, 0x55, 0xfd,
+	0x35, 0xd6, 0x83, 0xf5, 0xb1, 0xc8, 0x92, 0x34, 0xbb, 0xe8, 0x3b, 0x28, 0x60, 0xa7, 0xa1, 0xd0,
+	0x62, 0x5b, 0x00, 0xa6, 0xf1, 0x51, 0x6e, 0xb3, 0x0d, 0xe8, 0xea, 0x2e, 0x16, 0x49, 0xbf, 0x83,
+	0x52, 0x1c, 0x65, 0xb1, 0x18, 0x89, 0xa4, 0xef, 0xe2, 0x42, 0x7c, 0x86, 0xf3, 0x89, 0xea, 0x7b,
+	0x67, 0x1e, 0xfd, 0x05, 0xf4, 0xf8, 0xef, 0x00, 0x00, 0x00, 0xff, 0xff, 0xd7, 0x34, 0x7d, 0xa0,
+	0x11, 0x12, 0x00, 0x00,
 }