Skip to content

P
plugin
Commit 7a475642 authored by hezhengjun's avatar hezhengjun
Browse files
Options

add boss code

parent 8de84f0b
Expand all Hide whitespace changes
Inline Side-by-side
Showing with 840 additions and 0 deletions
plugin/dapp/bridgevmxgo/boss4x/Makefile 0 → 100644
View file @ 7a475642
proj := "build"
.PHONY: default build remote winset
SRC_CLI := 33cn/plugin/plugin/dapp/bridgevmxgo/boss4x
OUT := build
default: build
build:
@go build -o ${OUT}/boss4x
remote:
@go build -v -o ${OUT}/boss4x_remote -ldflags "-X ${SRC_CLI}/buildFlags.RPCAddr4Chain33=http://183.129.226.74:8901"
winset:
@CGO_ENABLED=0 GOOS=windows GOARCH=amd64 go build -o ${OUT}/boss4x.exe -ldflags "-X ${SRC_CLI}/buildFlags.RPCAddr4Chain33=http://183.129.226.74:8901"
clean:
@rm ${OUT}/*
plugin/dapp/bridgevmxgo/boss4x/buildFlags/flags.go 0 → 100644
View file @ 7a475642
package buildFlags
var RPCAddr4Chain33 string
var paraName string
plugin/dapp/bridgevmxgo/boss4x/chain33/deploy.go 0 → 100644
View file @ 7a475642
package chain33
import (
"github.com/33cn/plugin/plugin/dapp/bridgevmxgo/boss4x/chain33/offline"
"github.com/spf13/cobra"
)
func Chain33Cmd() *cobra.Command {
cmd := &cobra.Command{
Use: "chain33",
Short: "deploy to chain33",
}
cmd.AddCommand(
offline.Boss4xOfflineCmd(),
)
return cmd
}
plugin/dapp/bridgevmxgo/boss4x/chain33/offline/configLockedTokenOfflineSave.go 0 → 100644
View file @ 7a475642
package offline
import (
"fmt"
"math/big"
"github.com/33cn/plugin/plugin/dapp/bridgevmxgo/contracts/generated"
ebTypes "github.com/33cn/plugin/plugin/dapp/cross2eth/ebrelayer/types"
utilsRelayer "github.com/33cn/plugin/plugin/dapp/cross2eth/ebrelayer/utils"
evmAbi "github.com/33cn/plugin/plugin/dapp/evm/executor/abi"
"github.com/spf13/cobra"
)
/*
./boss4x chain33 offline set_offline_token -c 1MaP3rrwiLV1wrxPhDwAfHggtei1ByaKrP -s BTY -m 100000000000 -p 50 -k 0x027ca96466c71c7e7c5d73b7e1f43cb889b3bd65ebd2413eefd31c6709c262ae --chainID 33
./boss4x chain33 offline send -f chain33_set_offline_token.txt
*/
func ConfigLockedTokenOfflineSaveCmd() *cobra.Command {
cmd := &cobra.Command{
Use: "set_offline_token",
Short: "set config offline locked token",
Run: ConfigMultisignLockedTokenOfflineSave,
}
addConfigLockedTokenOfflineSaveFlags(cmd)
return cmd
}
func addConfigLockedTokenOfflineSaveFlags(cmd *cobra.Command) {
cmd.Flags().StringP("contract", "c", "", "bridgebank contract address")
_ = cmd.MarkFlagRequired("contract")
cmd.Flags().StringP("token", "t", "", "token addr")
cmd.Flags().StringP("symbol", "s", "", "token symbol")
_ = cmd.MarkFlagRequired("symbol")
cmd.Flags().StringP("threshold", "m", "0", "threshold")
_ = cmd.MarkFlagRequired("threshold")
cmd.Flags().Uint8P("percents", "p", 50, "percents")
cmd.Flags().StringP("key", "k", "", "the deployer private key")
_ = cmd.MarkFlagRequired("key")
cmd.Flags().StringP("note", "n", "", "transaction note info (optional)")
cmd.Flags().Float64P("fee", "f", 0, "contract gas fee (optional)")
}
func ConfigMultisignLockedTokenOfflineSave(cmd *cobra.Command, _ []string) {
contract, _ := cmd.Flags().GetString("contract")
token, _ := cmd.Flags().GetString("token")
symbol, _ := cmd.Flags().GetString("symbol")
threshold, _ := cmd.Flags().GetString("threshold")
percents, _ := cmd.Flags().GetUint8("percents")
bn := big.NewInt(1)
bn, _ = bn.SetString(utilsRelayer.TrimZeroAndDot(threshold), 10)
if token == "" || symbol == "BTY" {
token = ebTypes.BTYAddrChain33
}
parameter := fmt.Sprintf("configLockedTokenOfflineSave(%s,%s,%d,%d)", token, symbol, bn, percents)
_, packData, err := evmAbi.Pack(parameter, generated.BridgeBankABI, false)
if nil != err {
fmt.Println("configOfflineSaveAccount", "Failed to do abi.Pack due to:", err.Error())
return
}
callContractAndSignWrite(cmd, packData, contract, "chain33_set_offline_token")
}
plugin/dapp/bridgevmxgo/boss4x/chain33/offline/configOfflineSaveAccount.go 0 → 100644
View file @ 7a475642
package offline
import (
"fmt"
"github.com/33cn/plugin/plugin/dapp/bridgevmxgo/contracts/generated"
evmAbi "github.com/33cn/plugin/plugin/dapp/evm/executor/abi"
"github.com/spf13/cobra"
)
/*
./boss4x chain33 offline set_offline_addr -a 16skyHQA4YPPnhrDSSpZnexDzasS8BNx1R -c 1QD5pHMKZ9QWiNb9AsH3G1aG3Hashye83o -k 0x027ca96466c71c7e7c5d73b7e1f43cb889b3bd65ebd2413eefd31c6709c262ae --chainID 33
./boss4x chain33 offline send -f chain33_set_offline_addr.txt
*/
func ConfigOfflineSaveAccountCmd() *cobra.Command {
cmd := &cobra.Command{
Use: "set_offline_addr",
Short: "save config offline account",
Run: ConfigMultisignOfflineSaveAccount, //配置账户
}
addConfigOfflineSaveAccountFlags(cmd)
return cmd
}
func addConfigOfflineSaveAccountFlags(cmd *cobra.Command) {
cmd.Flags().StringP("address", "a", "", "multisign address")
_ = cmd.MarkFlagRequired("address")
cmd.Flags().StringP("contract", "c", "", "bridgebank contract address")
_ = cmd.MarkFlagRequired("contract")
cmd.Flags().StringP("key", "k", "", "the deployer private key")
_ = cmd.MarkFlagRequired("key")
cmd.Flags().StringP("note", "n", "", "transaction note info (optional)")
cmd.Flags().Float64P("fee", "f", 0, "contract gas fee (optional)")
}
func ConfigMultisignOfflineSaveAccount(cmd *cobra.Command, _ []string) {
multisign, _ := cmd.Flags().GetString("address")
contract, _ := cmd.Flags().GetString("contract")
parameter := fmt.Sprintf("configOfflineSaveAccount(%s)", multisign)
_, packData, err := evmAbi.Pack(parameter, generated.BridgeBankABI, false)
if nil != err {
fmt.Println("configOfflineSaveAccount", "Failed to do abi.Pack due to:", err.Error())
return
}
callContractAndSignWrite(cmd, packData, contract, "chain33_set_offline_addr")
}
plugin/dapp/bridgevmxgo/boss4x/chain33/offline/createERC20.go 0 → 100644
View file @ 7a475642
package offline
import (
"encoding/json"
"fmt"
"github.com/33cn/chain33/common/address"
"github.com/33cn/chain33/system/crypto/secp256k1"
"github.com/33cn/plugin/plugin/dapp/bridgevmxgo/contracts/generated"
erc20 "github.com/33cn/plugin/plugin/dapp/cross2eth/contracts/erc20/generated"
"github.com/33cn/plugin/plugin/dapp/dex/utils"
evmAbi "github.com/33cn/plugin/plugin/dapp/evm/executor/abi"
"github.com/33cn/plugin/plugin/dapp/evm/executor/vm/common"
"github.com/spf13/cobra"
)
/*
./boss4x chain33 offline create_erc20 -s YCC -k 0x027ca96466c71c7e7c5d73b7e1f43cb889b3bd65ebd2413eefd31c6709c262ae -o 1N6HstkyLFS8QCeVfdvYxx1xoryXoJtvvZ --chainID 33
./boss4x chain33 offline send -f deployErc20YCCChain33.txt
./boss4x chain33 offline approve_erc20 -a 330000000000 -s 1JmWVu1GEdQYSN1opxS9C39aS4NvG57yTr -c 1998HqVnt4JUirhC9KL5V71xYU8cFRn82c -k 0x027ca96466c71c7e7c5d73b7e1f43cb889b3bd65ebd2413eefd31c6709c262ae --chainID 33
./boss4x chain33 offline send -f approve_erc20.txt
./boss4x chain33 offline create_add_lock_list -c 1JmWVu1GEdQYSN1opxS9C39aS4NvG57yTr -k 0x027ca96466c71c7e7c5d73b7e1f43cb889b3bd65ebd2413eefd31c6709c262ae -t 1998HqVnt4JUirhC9KL5V71xYU8cFRn82c --chainID 33 -s YCC
./boss4x chain33 offline send -f create_add_lock_list.txt
./boss4x chain33 offline create_bridge_token -c 1JmWVu1GEdQYSN1opxS9C39aS4NvG57yTr -k 0x027ca96466c71c7e7c5d73b7e1f43cb889b3bd65ebd2413eefd31c6709c262ae -s YCC --chainID 33
./boss4x chain33 offline send -f create_bridge_token.txt
${Chain33Cli} evm abi call -a "${chain33BridgeBank}" -c "${chain33DeployAddr}" -b "getToken2address(YCC)"
./chain33-cli evm abi call -a 1JmWVu1GEdQYSN1opxS9C39aS4NvG57yTr -c 1N6HstkyLFS8QCeVfdvYxx1xoryXoJtvvZ -b 'getToken2address(YCC)'
*/
func CreateERC20Cmd() *cobra.Command {
cmd := &cobra.Command{
Use: "create_erc20",
Short: "create erc20 contracts and sign, default 3300*1e8 to be minted",
Run: CreateERC20,
}
CreateERC20Flags(cmd)
return cmd
}
//CreateERC20Flags ...
func CreateERC20Flags(cmd *cobra.Command) {
cmd.Flags().StringP("key", "k", "", "the deployer private key")
_ = cmd.MarkFlagRequired("key")
cmd.Flags().StringP("owner", "o", "", "owner address")
_ = cmd.MarkFlagRequired("owner")
cmd.Flags().StringP("symbol", "s", "", "token symbol")
_ = cmd.MarkFlagRequired("symbol")
cmd.Flags().Float64P("amount", "a", 0, "amount to be minted(optional),default to 3300*1e8")
}
func CreateERC20(cmd *cobra.Command, _ []string) {
symbol, _ := cmd.Flags().GetString("symbol")
owner, _ := cmd.Flags().GetString("owner")
amount, _ := cmd.Flags().GetFloat64("amount")
amountInt64 := int64(3300 * 1e8)
if 0 != int64(amount) {
amountInt64 = int64(amount)
}
privateKeyStr, _ := cmd.Flags().GetString("key")
var driver secp256k1.Driver
privateKeySli := common.FromHex(privateKeyStr)
privateKey, err := driver.PrivKeyFromBytes(privateKeySli)
if nil != err {
fmt.Println("Failed to do PrivKeyFromBytes")
return
}
fromAddr := address.PubKeyToAddress(privateKey.PubKey().Bytes())
from := common.Address{
Addr: fromAddr,
}
createPara := fmt.Sprintf("%s,%s,%s,%s", symbol, symbol, fmt.Sprintf("%d", amountInt64), owner)
content, txHash, err := utils.CreateContractAndSign(getTxInfo(cmd), erc20.ERC20Bin, erc20.ERC20ABI, createPara, "ERC20:"+symbol)
if nil != err {
fmt.Println("CreateContractAndSign erc20 fail")
return
}
newContractAddr := common.NewContractAddress(from, txHash).String()
Erc20Tx := &utils.Chain33OfflineTx{
ContractAddr: newContractAddr,
TxHash: common.Bytes2Hex(txHash),
SignedRawTx: content,
OperationName: "deploy ERC20:" + symbol,
}
data, err := json.MarshalIndent(Erc20Tx, "", " ")
if err != nil {
fmt.Println("MarshalIndent error", err.Error())
return
}
fmt.Println(string(data))
var txs []*utils.Chain33OfflineTx
txs = append(txs, Erc20Tx)
fileName := fmt.Sprintf("deployErc20%sChain33.txt", symbol)
fmt.Printf("Write all the txs to file: %s \n", fileName)
utils.WriteToFileInJson(fileName, txs)
}
func ApproveErc20Cmd() *cobra.Command {
cmd := &cobra.Command{
Use: "approve_erc20",
Short: "approve erc20",
Run: ApproveErc20, //配置账户
}
addApproveErc20Flags(cmd)
return cmd
}
func addApproveErc20Flags(cmd *cobra.Command) {
cmd.Flags().StringP("approve", "s", "", "approve addr")
_ = cmd.MarkFlagRequired("approve")
cmd.Flags().Float64P("amount", "a", 0, "approve amount")
_ = cmd.MarkFlagRequired("amount")
cmd.Flags().StringP("contract", "c", "", "Erc20 contract address")
_ = cmd.MarkFlagRequired("contract")
cmd.Flags().StringP("key", "k", "", "the deployer private key")
_ = cmd.MarkFlagRequired("key")
cmd.Flags().StringP("note", "n", "", "transaction note info (optional)")
cmd.Flags().Float64P("fee", "f", 0, "contract gas fee (optional)")
}
func ApproveErc20(cmd *cobra.Command, _ []string) {
contract, _ := cmd.Flags().GetString("contract")
approve, _ := cmd.Flags().GetString("approve")
amount, _ := cmd.Flags().GetFloat64("amount")
parameter := fmt.Sprintf("approve(%s,%d)", approve, int64(amount))
_, packData, err := evmAbi.Pack(parameter, generated.BridgeTokenABI, false)
if nil != err {
fmt.Println("configOfflineSaveAccount", "Failed to do abi.Pack due to:", err.Error())
return
}
callContractAndSignWrite(cmd, packData, contract, "approve_erc20")
}
func AddToken2LockListCmd() *cobra.Command {
cmd := &cobra.Command{
Use: "create_add_lock_list",
Short: "add token to lock list",
Run: AddToken2LockList, //配置账户
}
addAddToken2LockListFlags(cmd)
return cmd
}
func addAddToken2LockListFlags(cmd *cobra.Command) {
cmd.Flags().StringP("symbol", "s", "", "token symbol")
_ = cmd.MarkFlagRequired("symbol")
cmd.Flags().StringP("token", "t", "", "token addr")
_ = cmd.MarkFlagRequired("token")
cmd.Flags().StringP("contract", "c", "", "bridgebank contract address")
_ = cmd.MarkFlagRequired("contract")
cmd.Flags().StringP("key", "k", "", "the deployer private key")
_ = cmd.MarkFlagRequired("key")
cmd.Flags().StringP("note", "n", "", "transaction note info (optional)")
cmd.Flags().Float64P("fee", "f", 0, "contract gas fee (optional)")
}
func AddToken2LockList(cmd *cobra.Command, _ []string) {
contract, _ := cmd.Flags().GetString("contract")
symbol, _ := cmd.Flags().GetString("symbol")
token, _ := cmd.Flags().GetString("token")
parameter := fmt.Sprintf("addToken2LockList(%s,%s)", token, symbol)
_, packData, err := evmAbi.Pack(parameter, generated.BridgeBankABI, false)
if nil != err {
fmt.Println("configOfflineSaveAccount", "Failed to do abi.Pack due to:", err.Error())
return
}
callContractAndSignWrite(cmd, packData, contract, "create_add_lock_list")
}
func CreateNewBridgeTokenCmd() *cobra.Command {
cmd := &cobra.Command{
Use: "create_bridge_token",
Short: "create new token as ethereum asset on chain33, and it's should be done by operator",
Run: CreateNewBridgeToken, //配置账户
}
addCreateNewBridgeTokenFlags(cmd)
return cmd
}
func addCreateNewBridgeTokenFlags(cmd *cobra.Command) {
cmd.Flags().StringP("symbol", "s", "", "token symbol")
_ = cmd.MarkFlagRequired("symbol")
cmd.Flags().StringP("contract", "c", "", "bridgebank contract address")
_ = cmd.MarkFlagRequired("contract")
cmd.Flags().StringP("key", "k", "", "the deployer private key")
_ = cmd.MarkFlagRequired("key")
cmd.Flags().StringP("note", "n", "", "transaction note info (optional)")
cmd.Flags().Float64P("fee", "f", 0, "contract gas fee (optional)")
}
func CreateNewBridgeToken(cmd *cobra.Command, _ []string) {
contract, _ := cmd.Flags().GetString("contract")
symbol, _ := cmd.Flags().GetString("symbol")
parameter := fmt.Sprintf("createNewBridgeToken(%s)", symbol)
_, packData, err := evmAbi.Pack(parameter, generated.BridgeBankABI, false)
if nil != err {
fmt.Println("configOfflineSaveAccount", "Failed to do abi.Pack due to:", err.Error())
return
}
callContractAndSignWrite(cmd, packData, contract, "create_bridge_token")
}
plugin/dapp/bridgevmxgo/boss4x/chain33/offline/multisignSetup.go 0 → 100644
View file @ 7a475642
package offline
import (
"fmt"
"strings"
gnosis "github.com/33cn/plugin/plugin/dapp/cross2eth/contracts/gnosis/generated"
ebTypes "github.com/33cn/plugin/plugin/dapp/cross2eth/ebrelayer/types"
evmAbi "github.com/33cn/plugin/plugin/dapp/evm/executor/abi"
"github.com/spf13/cobra"
)
/*
./boss4x chain33 offline multisign_setup -m 1GrhufvPtnBCtfxDrFGcCoihmYMHJafuPn -o 168Sn1DXnLrZHTcAM9stD6t2P49fNuJfJ9,13KTf57aCkVVJYNJBXBBveiA5V811SrLcT,1JQwQWsShTHC4zxHzbUfYQK4kRBriUQdEe,1NHuKqoKe3hyv52PF8XBAyaTmJWAqA2Jbb -k 0x027ca96466c71c7e7c5d73b7e1f43cb889b3bd65ebd2413eefd31c6709c262ae --chainID 33
./boss4x chain33 offline send -f multisign_setup.txt
*/
func SetupCmd() *cobra.Command {
cmd := &cobra.Command{
Use: "multisign_setup",
Short: "Setup owners to contract",
Run: SetupOwner,
}
SetupOwnerFlags(cmd)
return cmd
}
func SetupOwnerFlags(cmd *cobra.Command) {
cmd.Flags().StringP("owner", "o", "", "owners's address, separated by ','")
_ = cmd.MarkFlagRequired("owner")
cmd.Flags().StringP("key", "k", "", "operator private key")
_ = cmd.MarkFlagRequired("operator")
cmd.Flags().StringP("multisign", "m", "", "multisign contract address")
_ = cmd.MarkFlagRequired("multisign")
}
func SetupOwner(cmd *cobra.Command, _ []string) {
multisign, _ := cmd.Flags().GetString("multisign")
owner, _ := cmd.Flags().GetString("owner")
owners := strings.Split(owner, ",")
BTYAddrChain33 := ebTypes.BTYAddrChain33
parameter := "setup(["
parameter += fmt.Sprintf("%s", owners[0])
for _, owner := range owners[1:] {
parameter += fmt.Sprintf(",%s", owner)
}
parameter += "], "
parameter += fmt.Sprintf("%d, %s, 0102, %s, %s, 0, %s)", len(owners), BTYAddrChain33, BTYAddrChain33, BTYAddrChain33, BTYAddrChain33)
_, packData, err := evmAbi.Pack(parameter, gnosis.GnosisSafeABI, false)
if nil != err {
fmt.Println("multisign_setup", "Failed to do abi.Pack due to:", err.Error())
return
}
callContractAndSignWrite(cmd, packData, multisign, "multisign_setup")
}
plugin/dapp/bridgevmxgo/boss4x/chain33/offline/multisignTransfer.go 0 → 100644
View file @ 7a475642
package offline
import (
"fmt"
"math/big"
"strings"
"github.com/33cn/plugin/plugin/dapp/cross2eth/contracts/gnosis/generated"
gnosis "github.com/33cn/plugin/plugin/dapp/cross2eth/contracts/gnosis/generated"
chain33Common "github.com/33cn/chain33/common"
"github.com/33cn/chain33/system/crypto/secp256k1"
erc20 "github.com/33cn/plugin/plugin/dapp/cross2eth/contracts/erc20/generated"
chain33Relayer "github.com/33cn/plugin/plugin/dapp/cross2eth/ebrelayer/relayer/chain33"
ebrelayerTypes "github.com/33cn/plugin/plugin/dapp/cross2eth/ebrelayer/types"
relayerutils "github.com/33cn/plugin/plugin/dapp/cross2eth/ebrelayer/utils"
evmAbi "github.com/33cn/plugin/plugin/dapp/evm/executor/abi"
"github.com/33cn/plugin/plugin/dapp/evm/executor/vm/common/math"
btcecsecp256k1 "github.com/btcsuite/btcd/btcec"
ethSecp256k1 "github.com/ethereum/go-ethereum/crypto/secp256k1"
"github.com/spf13/cobra"
)
/*
./boss4x chain33 offline create_multisign_transfer -a 10 -r 168Sn1DXnLrZHTcAM9stD6t2P49fNuJfJ9 -m 1NFDfEwne4kjuxAZrtYEh4kfSrnGSE7ap
./boss4x chain33 offline multisign_transfer -k 0x027ca96466c71c7e7c5d73b7e1f43cb889b3bd65ebd2413eefd31c6709c262a -s 0xcd284cd17456b73619fa609bb9e3105e8eff5d059c5e0b6eb1effbebd4d64144,0xe892212221b3b58211b90194365f4662764b6d5474ef2961ef77c909e31eeed3,0x9d19a2e9a440187010634f4f08ce36e2bc7b521581436a99f05568be94dc66ea,0x45d4ce009e25e6d5e00d8d3a50565944b2e3604aa473680a656b242d9acbff35 --chainID 33
./boss4x chain33 offline send -f multisign_transfer.txt
*/
type transferTxData struct {
Receiver string
Token string
MultisignAddr string
Data string
Amount float64
name string
}
func CreateMultisignTransferCmd() *cobra.Command {
cmd := &cobra.Command{
Use: "create_multisign_transfer",
Short: "create multisign transfer tx",
Run: CreateMultisignTransfer,
}
addCreateMultisignTransferFlags(cmd)
return cmd
}
func addCreateMultisignTransferFlags(cmd *cobra.Command) {
cmd.Flags().StringP("receiver", "r", "", "receive address")
_ = cmd.MarkFlagRequired("receiver")
cmd.Flags().Float64P("amount", "a", 0, "amount to transfer")
_ = cmd.MarkFlagRequired("amount")
cmd.Flags().StringP("token", "t", "", "erc20 address,not need to set for BTY(optional)")
//
cmd.Flags().StringP("address", "m", "", "multisign address")
_ = cmd.MarkFlagRequired("address")
}
func CreateMultisignTransfer(cmd *cobra.Command, _ []string) {
rpcLaddr, _ := cmd.Flags().GetString("rpc_laddr")
receiver, _ := cmd.Flags().GetString("receiver")
token, _ := cmd.Flags().GetString("token")
amount, _ := cmd.Flags().GetFloat64("amount")
multisign, _ := cmd.Flags().GetString("address")
//对于平台币转账，这个data只是个占位符，没有作用
dataStr := "0x"
safeTxGas := int64(10 * 10000)
baseGas := 0
gasPrice := 0
valueStr := relayerutils.ToWei(amount, 8).String()
//如果是bty转账,则直接将to地址设置为receiver,而如果是ERC20转账，则需要将其设置为token地址
to := receiver
//如果是erc20转账，则需要构建data数据
if "" != token {
parameter := fmt.Sprintf("transfer(%s, %s)", receiver, relayerutils.ToWei(amount, 8).String())
_, data, err := evmAbi.Pack(parameter, erc20.ERC20ABI, false)
if err != nil {
fmt.Println("Failed to do abi.Pack due to:", err.Error())
return
}
//对于其他erc20资产，直接将其设置为0
valueStr = "0"
to = token
dataStr = chain33Common.ToHex(data)
}
//获取nonce
nonce := getMulSignNonce(multisign, rpcLaddr)
parameter2getHash := fmt.Sprintf("getTransactionHash(%s, %s, %s, 0, %d, %d, %d, %s, %s, %d)", to, valueStr, dataStr,
safeTxGas, baseGas, gasPrice, ebrelayerTypes.NilAddrChain33, ebrelayerTypes.NilAddrChain33, nonce)
result := chain33Relayer.Query(multisign, parameter2getHash, multisign, rpcLaddr, generated.GnosisSafeABI)
if nil == result {
fmt.Println("Failed to getTransactionHash :", ebrelayerTypes.ErrGetTransactionHash)
return
}
contentHashArray := result.([32]byte)
contentHash := contentHashArray[:]
var txinfo transferTxData
txinfo.Receiver = receiver
txinfo.MultisignAddr = multisign
txinfo.Amount = amount
txinfo.Data = chain33Common.ToHex(contentHash)
txinfo.Token = token
txinfo.name = "create_multisign_transfer"
writeToFile(txinfo.name+".txt", txinfo)
}
func MultisignTransferCmd() *cobra.Command {
cmd := &cobra.Command{
Use: "multisign_transfer",
Short: "create multisign transfer tx and sign",
Run: MultisignTransfer,
}
addMultisignTransferFlags(cmd)
return cmd
}
func addMultisignTransferFlags(cmd *cobra.Command) {
cmd.Flags().StringP("file", "t", "create_multisign_transfer.txt", "tx file, default: create_multisign_transfer.txt")
cmd.Flags().StringP("keys", "s", "", "owners' private key, separated by ','")
_ = cmd.MarkFlagRequired("keys")
cmd.Flags().StringP("key", "k", "", "the deployer private key")
_ = cmd.MarkFlagRequired("key")
cmd.Flags().StringP("note", "n", "", "transaction note info (optional)")
cmd.Flags().Float64P("fee", "f", 0, "contract gas fee (optional)")
}
func MultisignTransfer(cmd *cobra.Command, _ []string) {
keysStr, _ := cmd.Flags().GetString("keys")
keys := strings.Split(keysStr, ",")
txFilePath, _ := cmd.Flags().GetString("file")
var txinfo transferTxData
err := paraseFile(txFilePath, &txinfo)
if err != nil {
fmt.Println("paraseFile Err:", err)
return
}
//对于平台币转账，这个data只是个占位符，没有作用
dataStr := "0x"
contentHash, err := chain33Common.FromHex(txinfo.Data)
safeTxGas := int64(10 * 10000)
baseGas := 0
gasPrice := 0
valueStr := relayerutils.ToWei(txinfo.Amount, 8).String()
//如果是bty转账,则直接将to地址设置为receiver,而如果是ERC20转账，则需要将其设置为token地址
to := txinfo.Receiver
//如果是erc20转账，则需要构建data数据
if "" != txinfo.Token {
parameter := fmt.Sprintf("transfer(%s, %s)", txinfo.Receiver, relayerutils.ToWei(txinfo.Amount, 8).String())
_, data, err := evmAbi.Pack(parameter, erc20.ERC20ABI, false)
if err != nil {
fmt.Println("evmAbi.Pack(parameter, erc20.ERC20ABI, false)", "Failed", err.Error())
return
}
//对于其他erc20资产，直接将其设置为0
valueStr = "0"
to = txinfo.Token
dataStr = chain33Common.ToHex(data)
}
var sigs []byte
for _, privateKey := range keys {
var driver secp256k1.Driver
privateKeySli, err := chain33Common.FromHex(privateKey)
if nil != err {
fmt.Println("evmAbi.Pack(parameter, erc20.ERC20ABI, false)", "Failed", err.Error())
return
}
ownerPrivateKey, err := driver.PrivKeyFromBytes(privateKeySli)
if nil != err {
fmt.Println("evmAbi.Pack(parameter, erc20.ERC20ABI, false)", "Failed", err.Error())
return
}
temp, _ := btcecsecp256k1.PrivKeyFromBytes(btcecsecp256k1.S256(), ownerPrivateKey.Bytes())
privateKey4chain33Ecdsa := temp.ToECDSA()
sig, err := ethSecp256k1.Sign(contentHash, math.PaddedBigBytes(privateKey4chain33Ecdsa.D, 32))
if nil != err {
fmt.Println("evmAbi.Pack(parameter, erc20.ERC20ABI, false)", "Failed", err.Error())
return
}
sig[64] += 27
sigs = append(sigs, sig...)
}
//构造execTransaction参数
parameter2Exec := fmt.Sprintf("execTransaction(%s, %s, %s, 0, %d, %d, %d, %s, %s, %s)", to, valueStr, dataStr,
safeTxGas, baseGas, gasPrice, ebrelayerTypes.NilAddrChain33, ebrelayerTypes.NilAddrChain33, chain33Common.ToHex(sigs))
_, packData, err := evmAbi.Pack(parameter2Exec, gnosis.GnosisSafeABI, false)
if nil != err {
fmt.Println("execTransaction evmAbi.Pack", "Failed", err.Error())
return
}
callContractAndSignWrite(cmd, packData, txinfo.MultisignAddr, "multisign_transfer")
}
func getMulSignNonce(mulsign, rpcLaddr string) int64 {
parameter := fmt.Sprintf("nonce()")
result := chain33Relayer.Query(mulsign, parameter, mulsign, rpcLaddr, gnosis.GnosisSafeABI)
if nil == result {
return 0
}
nonce := result.(*big.Int)
return nonce.Int64()
}
plugin/dapp/bridgevmxgo/boss4x/chain33/offline/offline.go 0 → 100644
View file @ 7a475642
package offline
import (
"encoding/json"
"fmt"
"io/ioutil"
"os"
"github.com/33cn/plugin/plugin/dapp/dex/utils"
evmtypes "github.com/33cn/plugin/plugin/dapp/evm/types"
"github.com/ethereum/go-ethereum/common"
"github.com/spf13/cobra"
)
var crossXfileName = "deployBridgevmxgo2Chain33.txt"
func Boss4xOfflineCmd() *cobra.Command {
cmd := &cobra.Command{
Use: "offline",
Short: "create and sign offline tx to deploy and set cross contracts to chain33",
}
cmd.AddCommand(
CreateBridgevmxgoCmd(),
SendSignTxs2Chain33Cmd(),
CreateERC20Cmd(),
ApproveErc20Cmd(),
AddToken2LockListCmd(),
CreateNewBridgeTokenCmd(),
SetupCmd(),
ConfigOfflineSaveAccountCmd(),
ConfigLockedTokenOfflineSaveCmd(),
CreateMultisignTransferCmd(),
MultisignTransferCmd(),
)
return cmd
}
func SendSignTxs2Chain33Cmd() *cobra.Command {
cmd := &cobra.Command{
Use: "send",
Short: "send all the txs to chain33 in serial",
Run: sendSignTxs2Chain33,
}
addSendSignTxs2Chain33Flags(cmd)
return cmd
}
func addSendSignTxs2Chain33Flags(cmd *cobra.Command) {
cmd.Flags().StringP("file", "f", "", "signed tx file")
_ = cmd.MarkFlagRequired("file")
}
func sendSignTxs2Chain33(cmd *cobra.Command, _ []string) {
filePath, _ := cmd.Flags().GetString("file")
url, _ := cmd.Flags().GetString("rpc_laddr")
utils.SendSignTxs2Chain33(filePath, url)
}
func getTxInfo(cmd *cobra.Command) *utils.TxCreateInfo {
privateKey, _ := cmd.Flags().GetString("key")
expire, _ := cmd.Flags().GetString("expire")
note, _ := cmd.Flags().GetString("note")
fee, _ := cmd.Flags().GetFloat64("fee")
paraName, _ := cmd.Flags().GetString("paraName")
chainID, _ := cmd.Flags().GetInt32("chainID")
feeInt64 := int64(fee*1e4) * 1e4
info := &utils.TxCreateInfo{
PrivateKey: privateKey,
Expire: expire,
Note: note,
Fee: feeInt64,
ParaName: paraName,
ChainID: chainID,
}
return info
}
func writeToFile(fileName string, content interface{}) {
jbytes, err := json.MarshalIndent(content, "", "\t")
if err != nil {
panic(err)
}
err = ioutil.WriteFile(fileName, jbytes, 0666)
if err != nil {
fmt.Println("Failed to write to file:", fileName)
}
fmt.Println("tx is written to file: ", fileName)
}
func paraseFile(file string, result interface{}) error {
_, err := os.Stat(file)
if err != nil {
fmt.Println(err.Error())
return err
}
f, err := os.Open(file)
if err != nil {
panic(err)
}
b, err := ioutil.ReadAll(f)
if err != nil {
panic(err)
}
return json.Unmarshal(b, result)
}
func callContractAndSignWrite(cmd *cobra.Command, para []byte, contractAddr, name string) {
action := &evmtypes.EVMContractAction{Amount: 0, GasLimit: 0, GasPrice: 0, Note: name, Para: para, ContractAddr: contractAddr}
content, txHash, err := utils.CallContractAndSign(getTxInfo(cmd), action, contractAddr)
if nil != err {
fmt.Println("CallContractAndSign", "Failed", err.Error())
return
}
Tx := &utils.Chain33OfflineTx{
ContractAddr: contractAddr,
TxHash: common.Bytes2Hex(txHash),
SignedRawTx: content,
OperationName: name,
}
_, err = json.MarshalIndent(Tx, "", " ")
if err != nil {
fmt.Println("MarshalIndent error", err.Error())
return
}
var txs []*utils.Chain33OfflineTx
txs = append(txs, Tx)
fileName := fmt.Sprintf(Tx.OperationName + ".txt")
fmt.Printf("Write all the txs to file: %s \n", fileName)
utils.WriteToFileInJson(fileName, txs)
}
plugin/dapp/bridgevmxgo/boss4x/cli.go 0 → 100644
View file @ 7a475642
package main
import (
"fmt"
"net/http"
"os"
"strings"
"github.com/33cn/plugin/plugin/dapp/bridgevmxgo/boss4x/buildFlags"
"github.com/33cn/plugin/plugin/dapp/bridgevmxgo/boss4x/chain33"
"github.com/spf13/cobra"
)
func main() {
if buildFlags.RPCAddr4Chain33 == "" {
buildFlags.RPCAddr4Chain33 = "http://localhost:8801"
}
buildFlags.RPCAddr4Chain33 = testTLS(buildFlags.RPCAddr4Chain33)
rootCmd := RootCmd()
rootCmd.PersistentFlags().String("rpc_laddr", buildFlags.RPCAddr4Chain33, "http url")
rootCmd.PersistentFlags().String("paraName", "", "para chain name,Eg:user.p.fzm.")
rootCmd.PersistentFlags().String("expire", "120m", "transaction expire time (optional)")
rootCmd.PersistentFlags().Int32("chainID", 0, "chain id, default to 0")
if err := rootCmd.Execute(); err != nil {
fmt.Println(err)
os.Exit(1)
}
}
// RootCmd Cmd x2ethereum client command
func RootCmd() *cobra.Command {
cmd := &cobra.Command{
Use: "boss for bridgevmxgo",
Short: "manage create offline tx or deploy contracts(bridgevmxgo) for test",
}
cmd.AddCommand(
chain33.Chain33Cmd(),
)
return cmd
}
func testTLS(RPCAddr string) string {
rpcaddr := RPCAddr
if !strings.HasPrefix(rpcaddr, "http://") {
return RPCAddr
}
// if http://
if rpcaddr[len(rpcaddr)-1] != '/' {
rpcaddr += "/"
}
rpcaddr += "test"
/* #nosec */
resp, err := http.Get(rpcaddr)
if err != nil {
return "https://" + RPCAddr[7:]
}
defer resp.Body.Close()
if resp.StatusCode == 200 {
return RPCAddr
}
return "https://" + RPCAddr[7:]
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment