diff --git a/client/client.go b/client/client.go index ea567a8..9a72930 100644 --- a/client/client.go +++ b/client/client.go @@ -5,9 +5,7 @@ import ( "errors" . "github.com/browser/log" "github.com/browser/types" - "github.com/ethereum/go-ethereum/common/hexutil" "go.uber.org/zap" - "math/big" ) const ( @@ -24,301 +22,126 @@ const ( methodDposIrreversible = "dpos_irreversible" ) -func GetCurrentBlockInfo() (int64, string, error) { - request := NewRPCRequest("2.0", methodCurrentBlock, false) - jsonParsed, err := SendRPCRequest(request) +func GetCurrentBlockInfo() (*types.RpcBlock, error) { + data := &types.RpcBlock{} + err := GetData(methodCurrentBlock, data, false) if err != nil { - ZapLog.Error("GetCurrentBlockInfo SendRPCRequest error", zap.Error(err)) - return 0, "", err + ZapLog.Error("methodCurrentBlock error", zap.Error(err)) + return nil, err } - number, _ := big.NewInt(0).SetString(string(jsonParsed.Path("result.number").Data().(json.Number)), 10) - miner := jsonParsed.Path("result.miner").Data().(string) - return number.Int64(), miner, nil + return data, nil } -func GetAssetInfoByName(assetName string) (*types.AssetObject, error) { - request := NewRPCRequest("2.0", methodAssetInfoByName, assetName) - jsonParsed, err := SendRPCRequest(request) +func GetBlockByNumber(height uint64) (*types.RpcBlock, error) { + data := &types.RpcBlock{} + err := GetData(methodBlockByNumber, data, height, false) if err != nil { - ZapLog.Error("GetAssetInfoByName SendRPCRequest error", zap.Error(err), zap.String("name", assetName)) + ZapLog.Error("GetBlockByNumber error", zap.Error(err)) return nil, err } - if result := jsonParsed.Path("result").Data(); result == nil { - return nil, nil - } - mapAsset := jsonParsed.S("result").ChildrenMap() - asset := &types.AssetObject{} - assetId, _ := big.NewInt(0).SetString(string(mapAsset["assetId"].Data().(json.Number)), 10) - asset.AssetId = assetId.Uint64() - asset.AssetName = mapAsset["assetName"].Data().(string) - asset.Symbol = mapAsset["symbol"].Data().(string) - asset.Amount, _ = big.NewInt(0).SetString(string(mapAsset["amount"].Data().(json.Number)), 10) - decimals, _ := big.NewInt(0).SetString(string(mapAsset["decimals"].Data().(json.Number)), 10) - asset.Decimals = decimals.Uint64() - asset.Founder = types.Name(mapAsset["founder"].Data().(string)) - asset.Owner = types.Name(mapAsset["owner"].Data().(string)) - asset.UpperLimit, _ = big.NewInt(0).SetString(string(mapAsset["upperLimit"].Data().(json.Number)), 10) - return asset, nil + data.Time = data.Time / 1000000000 + return data, nil } -func GetAssetInfoById(assetid uint64) (*types.AssetObject, error) { - request := NewRPCRequest("2.0", methodAssetInfoByID, assetid) - jsonParsed, err := SendRPCRequest(request) +func GetAssetInfoByName(assetName string) (*types.AssetObject, error) { + data := &types.AssetObject{} + err := GetData(methodAssetInfoByName, data, assetName) if err != nil { - ZapLog.Error("GetAssetInfoById SendRPCRequest error", zap.Error(err), zap.Uint64("assetId", assetid)) + ZapLog.Error("GetAssetInfoByName error", zap.Error(err), zap.String("assetName", assetName)) return nil, err } - if result := jsonParsed.Path("result").Data(); result == nil { - return nil, nil - } - mapAsset := jsonParsed.S("result").ChildrenMap() - asset := &types.AssetObject{} - assetId, _ := big.NewInt(0).SetString(string(mapAsset["assetId"].Data().(json.Number)), 10) - asset.AssetId = assetId.Uint64() - asset.AssetName = mapAsset["assetName"].Data().(string) - asset.Symbol = mapAsset["symbol"].Data().(string) - asset.Amount, _ = big.NewInt(0).SetString(string(mapAsset["amount"].Data().(json.Number)), 10) - decimals, _ := big.NewInt(0).SetString(string(mapAsset["decimals"].Data().(json.Number)), 10) - asset.Decimals = decimals.Uint64() - asset.Founder = types.Name(mapAsset["founder"].Data().(string)) - asset.Owner = types.Name(mapAsset["owner"].Data().(string)) - asset.UpperLimit, _ = big.NewInt(0).SetString(string(mapAsset["upperLimit"].Data().(json.Number)), 10) - return asset, nil + return data, nil } -func GetBlockTimeByNumber(number int64) (int64, error) { - request := NewRPCRequest("2.0", methodBlockByNumber, number, true) - jsonParsed, err := SendRPCRequest(request) +func GetAssetInfoById(assetid uint64) (*types.AssetObject, error) { + data := &types.AssetObject{} + err := GetData(methodAssetInfoByID, data, assetid) if err != nil { - ZapLog.Error("GetBlockByNumber SendRPCRequest error", zap.Error(err), zap.Int64("height", number)) - return 0, err + ZapLog.Error("GetAssetInfoById error", zap.Error(err), zap.Uint64("assetid", assetid)) + return nil, err } - value, _ := big.NewInt(0).SetString(string(jsonParsed.Path("result.timestamp").Data().(json.Number)), 10) - return value.Int64() / 1000000000, nil + return data, nil } -func GetCandidatesCount() (int64, error) { - request := NewRPCRequest("2.0", methodDposCadidatesSize, 0) - jsonParsed, err := SendRPCRequest(request) +func GetCandidatesCount() (uint64, error) { + data := uint64(0) + err := GetData(methodDposCadidatesSize, &data, 0) if err != nil { - ZapLog.Error("GetCandidatesCount SendRPCRequest error", zap.Error(err)) - return 0, err + ZapLog.Error("GetCandidatesCount error", zap.Error(err)) + return data, err } - registerCnt, _ := big.NewInt(0).SetString(string(jsonParsed.Path("result").Data().(json.Number)), 10) - return registerCnt.Int64(), nil + return data, nil } -//GetBlockAndResult get block and produce log func GetBlockAndResult(number int64) (*types.BlockAndResult, error) { - request := NewRPCRequest("2.0", methodBlockAndResultByNumber, number) - jsonParsed, err := SendRPCRequest(request) + data := &types.BlockAndResult{} + err := GetData(methodBlockAndResultByNumber, &data, number) if err != nil { - ZapLog.Error("GetBlockAndResult SendRPCRequest error", zap.Error(err), zap.Int64("height", number)) - return nil, err - } - if result := jsonParsed.Path("result").Data(); result == nil { - return nil, nil + ZapLog.Error("GetBlockAndResult error", zap.Error(err), zap.Int64("height", number)) + return data, err } - ret := &types.BlockAndResult{} - //-----------------Block--------------- - HeadMap := jsonParsed.S("result", "block").ChildrenMap() - block := &types.Block{} - ret.Hash = types.HexToHash(HeadMap["hash"].Data().(string)) - head := &types.Header{} - head.ParentHash = types.HexToHash(HeadMap["parentHash"].Data().(string)) - head.Coinbase = types.Name(HeadMap["miner"].Data().(string)) - head.Difficulty, _ = big.NewInt(0).SetString(string(HeadMap["difficulty"].Data().(json.Number)), 10) - head.Number, _ = big.NewInt(0).SetString(string(HeadMap["number"].Data().(json.Number)), 10) - gasLimit, _ := big.NewInt(0).SetString(string(HeadMap["gasLimit"].Data().(json.Number)), 10) - head.GasLimit = gasLimit.Uint64() - gasUsed, _ := big.NewInt(0).SetString(string(HeadMap["gasUsed"].Data().(json.Number)), 10) - head.GasUsed = gasUsed.Uint64() - time, _ := big.NewInt(0).SetString(string(HeadMap["timestamp"].Data().(json.Number)), 10) - head.Time = uint(time.Uint64() / 1000000000) - head.Extra, _ = hexutil.Decode(HeadMap["extraData"].Data().(string)) + data.Block.Time = data.Block.Time / 1000000000 + return data, nil +} - txs := make([]*types.RPCTransaction, 0) - txChildren := jsonParsed.S("result", "block", "transactions").Children() - for _, txChild := range txChildren { - tx := &types.RPCTransaction{} - gasAssetId, _ := big.NewInt(0).SetString(string(txChild.Path("gasAssetID").Data().(json.Number)), 10) - tx.GasAssetID = gasAssetId.Uint64() - tx.GasPrice, _ = big.NewInt(0).SetString(string(txChild.Path("gasPrice").Data().(json.Number)), 10) - tx.Hash = types.HexToHash(txChild.Path("txHash").Data().(string)) - tx.GasCost, _ = big.NewInt(0).SetString(string(txChild.Path("gasCost").Data().(json.Number)), 10) - tx.RPCActions = make([]*types.RPCAction, 0) - acChildren := txChild.S("actions").Children() - for _, acChild := range acChildren { - ac := &types.RPCAction{} - tp, _ := big.NewInt(0).SetString(string(acChild.Path("type").Data().(json.Number)), 10) - ac.Type = types.ActionType(tp.Uint64()) - nonce, _ := big.NewInt(0).SetString(string(acChild.Path("nonce").Data().(json.Number)), 10) - ac.Nonce = nonce.Uint64() - assetId, _ := big.NewInt(0).SetString(string(acChild.Path("assetID").Data().(json.Number)), 10) - ac.AssetID = assetId.Uint64() - ac.From = types.Name(acChild.Path("from").Data().(string)) - ac.To = types.Name(acChild.Path("to").Data().(string)) - gas, _ := big.NewInt(0).SetString(string(acChild.Path("gas").Data().(json.Number)), 10) - ac.GasLimit = gas.Uint64() - ac.Amount, _ = big.NewInt(0).SetString(string(acChild.Path("value").Data().(json.Number)), 10) - ac.Remark, _ = hexutil.Decode(acChild.Path("remark").Data().(string)) - ac.Payload, _ = hexutil.Decode(acChild.Path("payload").Data().(string)) - ac.ActionHash = types.HexToHash(acChild.Path("actionHash").Data().(string)) - tx.RPCActions = append(tx.RPCActions, ac) - } - txs = append(txs, tx) - } - block.Head = head - block.Txs = txs - ret.Block = block - //-----------------Receipt--------------- - receipts := make([]*types.Receipt, 0) - receiptsChildren := jsonParsed.S("result", "receipts").Children() - for _, receiptsChild := range receiptsChildren { - receipt := &types.Receipt{} - CumulativeGasUsed, _ := big.NewInt(0).SetString(string(receiptsChild.Path("CumulativeGasUsed").Data().(json.Number)), 10) - receipt.CumulativeGasUsed = CumulativeGasUsed.Uint64() - receipt.TxHash = types.HexToHash(receiptsChild.Path("TxHash").Data().(string)) - TotalGasUsed, _ := big.NewInt(0).SetString(string(receiptsChild.Path("TotalGasUsed").Data().(json.Number)), 10) - receipt.TotalGasUsed = TotalGasUsed.Uint64() - receipt.ActionResults = make([]*types.ActionResult, 0) - reChildren := receiptsChild.S("ActionResults").Children() - for _, reChild := range reChildren { - actionResult := &types.ActionResult{} - Status, _ := big.NewInt(0).SetString(string(reChild.Path("Status").Data().(json.Number)), 10) - actionResult.Status = Status.Uint64() - GasUsed, _ := big.NewInt(0).SetString(string(reChild.Path("GasUsed").Data().(json.Number)), 10) - actionResult.GasUsed = GasUsed.Uint64() - actionResult.Error = reChild.Path("Error").Data().(string) - actionResult.GasAllot = make([]*types.GasDistribution, 0) - gasAllotChildren := reChild.S("GasAllot").Children() - for _, gasAllotChild := range gasAllotChildren { - gasDistribution := &types.GasDistribution{} - gasDistribution.Account = types.Name(gasAllotChild.Path("name").Data().(string)) - gas, _ := big.NewInt(0).SetString(string(gasAllotChild.Path("gas").Data().(json.Number)), 10) - gasDistribution.Gas = gas.Uint64() - typeId, _ := big.NewInt(0).SetString(string(gasAllotChild.Path("typeId").Data().(json.Number)), 10) - gasDistribution.Reason = typeId.Uint64() - actionResult.GasAllot = append(actionResult.GasAllot, gasDistribution) - } - receipt.ActionResults = append(receipt.ActionResults, actionResult) - } - receipts = append(receipts, receipt) +func GetChainConfig() (*types.ChainConfig, error) { + data := &types.ChainConfig{} + err := GetData(methodChainConfig, &data) + if err != nil { + ZapLog.Error("GetChainConfig error", zap.Error(err)) + return data, err } - ret.Receipts = receipts - //-----------------DetailTx--------------- - detailTxs := make([]*types.DetailTx, 0) - detailTxsChildren := jsonParsed.S("result", "detailTxs").Children() - for _, detailTxsChild := range detailTxsChildren { - detailTx := &types.DetailTx{} - detailTx.TxHash = types.HexToHash(detailTxsChild.Path("txhash").Data().(string)) - detailTx.InternalActions = make([]*types.InternalAction, 0) - iTxsChildren := detailTxsChild.S("actions").Children() - for _, iTxsChild := range iTxsChildren { - internalTxs := &types.InternalAction{} - internalTxs.InternalLogs = make([]*types.InternalLog, 0) - iTxChildren := iTxsChild.S("internalActions").Children() - for _, iTxChild := range iTxChildren { - itx := &types.InternalLog{} - itx.ActionType = iTxChild.Path("actionType").Data().(string) - gasUsed, _ := big.NewInt(0).SetString(string(iTxChild.Path("gasUsed").Data().(json.Number)), 10) - itx.GasUsed = gasUsed.Uint64() - gasLimit, _ := big.NewInt(0).SetString(string(iTxChild.Path("gasLimit").Data().(json.Number)), 10) - itx.GasLimit = gasLimit.Uint64() - depth, _ := big.NewInt(0).SetString(string(iTxChild.Path("depth").Data().(json.Number)), 10) - itx.Depth = depth.Uint64() - itx.Error = iTxChild.Path("error").Data().(string) - actionMap := iTxChild.S("action").ChildrenMap() - rpcAction := &types.RPCAction{} - tp, _ := big.NewInt(0).SetString(string(actionMap["type"].Data().(json.Number)), 10) - rpcAction.Type = types.ActionType(tp.Uint64()) - nonce, _ := big.NewInt(0).SetString(string(actionMap["nonce"].Data().(json.Number)), 10) - rpcAction.Nonce = nonce.Uint64() - rpcAction.From = types.Name(actionMap["from"].Data().(string)) - rpcAction.To = types.Name(actionMap["to"].Data().(string)) - assetID, _ := big.NewInt(0).SetString(string(actionMap["assetID"].Data().(json.Number)), 10) - rpcAction.AssetID = assetID.Uint64() - gas, _ := big.NewInt(0).SetString(string(actionMap["gas"].Data().(json.Number)), 10) - rpcAction.GasLimit = gas.Uint64() - rpcAction.Amount, _ = big.NewInt(0).SetString(string(actionMap["value"].Data().(json.Number)), 10) - rpcAction.Payload, _ = hexutil.Decode(actionMap["payload"].Data().(string)) - itx.Action = rpcAction - internalTxs.InternalLogs = append(internalTxs.InternalLogs, itx) - } - detailTx.InternalActions = append(detailTx.InternalActions, internalTxs) - } - detailTxs = append(detailTxs, detailTx) + return data, nil +} + +func GetAccountByName(name string) (*types.Account, error) { + data := &types.Account{} + err := GetData(methodGetAccountByName, &data, name) + if err != nil { + ZapLog.Error("GetAccountByName error", zap.Error(err), zap.String("name", name)) + return data, err } - ret.DetailTxs = detailTxs - return ret, nil + return data, nil } -func GetChainConfig() (*types.ChainConfig, error) { - request := NewRPCRequest("2.0", methodChainConfig, false) - jsonParsed, err := SendRPCRequest(request) +func GetDposIrreversible() (*types.DposIrreversible, error) { + data := &types.DposIrreversible{} + err := GetData(methodDposIrreversible, &data) if err != nil { - ZapLog.Error("GetChainConfig SendRPCRequest error", zap.Error(err)) - return nil, err + ZapLog.Error("GetDposIrreversible error", zap.Error(err)) + return data, err } - if result := jsonParsed.Path("result").Data(); result == nil { - return nil, err + return data, nil +} + +func GetCode(name string) (*types.Code, error) { + data := &types.Code{} + err := GetData(methodGetCode, &data) + if err != nil { + ZapLog.Error("GetCode error", zap.Error(err), zap.String("name", name)) + return data, err } - chainConfig := &types.ChainConfig{} - chainConfig.BootNodes = make([]string, 0) - chainConfigMap := jsonParsed.S("result").ChildrenMap() - chainConfig.ChainID, _ = big.NewInt(0).SetString(string(chainConfigMap["chainId"].Data().(json.Number)), 10) - chainConfig.ChainName = chainConfigMap["chainName"].Data().(string) - chainConfig.AssetName = chainConfigMap["assetName"].Data().(string) - chainConfig.SysName = chainConfigMap["systemName"].Data().(string) - chainConfig.AccountName = chainConfigMap["accountName"].Data().(string) - chainConfig.DposName = chainConfigMap["dposName"].Data().(string) - chainConfig.FeeName = chainConfigMap["feeName"].Data().(string) - chainConfig.SysToken = chainConfigMap["systemToken"].Data().(string) - dPosCfg := &types.DposConfig{} - dPosConfigMap := jsonParsed.S("result", "dposParams").ChildrenMap() - tmp, _ := big.NewInt(0).SetString(string(dPosConfigMap["blockInterval"].Data().(json.Number)), 10) - dPosCfg.BlockInterval = tmp.Uint64() - tmp, _ = tmp.SetString(string(dPosConfigMap["blockFrequency"].Data().(json.Number)), 10) - dPosCfg.BlockFrequency = tmp.Uint64() - tmp, _ = tmp.SetString(string(dPosConfigMap["candidateScheduleSize"].Data().(json.Number)), 10) - dPosCfg.CandidateScheduleSize = tmp.Uint64() - chainConfig.DposCfg = dPosCfg - return chainConfig, nil + return data, nil } -func GetAccountByName(name string) (*types.Account, error) { - request := NewRPCRequest("2.0", methodGetAccountByName, name) +func GetData(method string, outData interface{}, params ...interface{}) error { + request := NewRPCRequest("2.0", method, params...) jsonParsed, err := SendRPCRequest(request) if err != nil { - ZapLog.Error("GetAccountByName SendRPCRequest error", zap.Error(err), zap.String("name", name)) - return nil, err + ZapLog.Error("GetData error", zap.Error(err), zap.String("method", method)) + return err } - if result := jsonParsed.Path("result").Data(); result == nil { - return nil, err + result := jsonParsed.Path("result") + if result.Data() == nil { + return err } - account := &types.Account{ - AcctName: types.Name(name), + err = json.Unmarshal([]byte(result.String()), outData) + if err != nil { + ZapLog.Error("Unmarshal error", zap.Error(err), zap.String("method", method)) + return err } - accountInfoMap := jsonParsed.S("result").ChildrenMap() - founder := accountInfoMap["founder"].Data().(string) - account.Founder = types.Name(founder) - accountId, _ := big.NewInt(0).SetString(string(accountInfoMap["accountID"].Data().(json.Number)), 10) - account.AccountID = accountId.Uint64() - number, _ := big.NewInt(0).SetString(string(accountInfoMap["number"].Data().(json.Number)), 10) - account.Number = number.Uint64() - nonce, _ := big.NewInt(0).SetString(string(accountInfoMap["nonce"].Data().(json.Number)), 10) - account.Nonce = nonce.Uint64() - account.Code = make([]byte, 0) - code := accountInfoMap["code"].Data().(string) - account.Code = append(account.Code, []byte(code)...) - account.CodeHash = types.HexToHash(accountInfoMap["codeHash"].Data().(string)) - authorVersion := accountInfoMap["authorVersion"].Data().(string) - account.AuthorVersion.SetBytes([]byte(authorVersion)) - codeSize, _ := big.NewInt(0).SetString(string(accountInfoMap["codeSize"].Data().(json.Number)), 10) - account.CodeSize = codeSize.Uint64() - threshold, _ := big.NewInt(0).SetString(string(accountInfoMap["threshold"].Data().(json.Number)), 10) - account.Threshold = threshold.Uint64() - return account, nil + return nil + } func SendRawTransaction(rawData string) (types.Hash, error) { @@ -343,39 +166,3 @@ func SendRawTransaction(rawData string) (types.Hash, error) { return hash, nil } } - -func GetDposIrreversible() (*types.DposIrreversible, error) { - request := NewRPCRequest("2.0", methodDposIrreversible) - jsonParsed, err := SendRPCRequest(request) - if err != nil { - ZapLog.Error("GetDposIrreversible SendRPCRequest error", zap.Error(err)) - return nil, err - } - if result := jsonParsed.Path("result").Data(); result == nil { - ZapLog.Error("GetDposIrreversible response to json error", zap.Error(err)) - return nil, err - } - response := &types.DposIrreversible{} - dPosIrreversibleMap := jsonParsed.S("result").ChildrenMap() - reversible, _ := big.NewInt(0).SetString(string(dPosIrreversibleMap["reversible"].Data().(json.Number)), 10) - response.Reversible = reversible.Uint64() - proposedIrreversible, _ := big.NewInt(0).SetString(string(dPosIrreversibleMap["proposedIrreversible"].Data().(json.Number)), 10) - response.ProposedIrreversible = proposedIrreversible.Uint64() - bftIrreversible, _ := big.NewInt(0).SetString(string(dPosIrreversibleMap["bftIrreversible"].Data().(json.Number)), 10) - response.BftIrreversible = bftIrreversible.Uint64() - return response, nil -} - -func GetCode(name string) (string, error) { - request := NewRPCRequest("2.0", methodGetCode, name) - jsonParsed, err := SendRPCRequest(request) - if err != nil { - ZapLog.Error("GetDposIrreversible SendRPCRequest error", zap.Error(err), zap.String("name", name)) - return "", err - } - if result := jsonParsed.Path("result").Data(); result == nil { - return "", err - } - code := jsonParsed.S("result").Data().(string) - return code, nil -} diff --git a/client/client_test.go b/client/client_test.go index 81a736d..1f84d98 100644 --- a/client/client_test.go +++ b/client/client_test.go @@ -1,6 +1,7 @@ package client import ( + "github.com/browser/types" "testing" ) @@ -20,3 +21,11 @@ func TestSendRawTransaction(t *testing.T) { } t.Log(hash) } + +func TestGetCurrentBlockInfo(t *testing.T) { + data := &types.RpcBlock{} + err := GetData(methodCurrentBlock, data, false) + if err != nil { + t.Failed() + } +} diff --git a/config.yaml b/config.yaml index 8a3b9ef..c64fe9f 100644 --- a/config.yaml +++ b/config.yaml @@ -6,7 +6,7 @@ browser: port: 3306 database: ft node: - rpcHost: http://192.168.1.148:3090 + rpcHost: http://192.168.1.148:9090 log: level: info #error info debug file: @@ -15,7 +15,7 @@ browser: rotationTime: 1 #time.Duration 1:day 2:hour maxAge: 15 #day console: true - syncBlockShowNumber: 1000 + syncBlockShowNumber: 1 tasks: - block - txs diff --git a/config/config.go b/config/config.go index e31e1c7..b55eba7 100644 --- a/config/config.go +++ b/config/config.go @@ -48,5 +48,5 @@ type ChainConfig struct { CandidateScheduleSize uint64 BlockFrequency uint64 ChainId uint64 - StartTime int64 + StartTime uint64 } diff --git a/db/account.go b/db/account.go index 80b83c5..f119038 100644 --- a/db/account.go +++ b/db/account.go @@ -22,8 +22,8 @@ type MysqlAccount struct { Permissions string ContractCode string CodeHash string - Created uint - ContractCreated uint + Created uint64 + ContractCreated uint64 Suicide bool Destroy bool Description string diff --git a/db/action.go b/db/action.go index b4dbdfa..96065e1 100644 --- a/db/action.go +++ b/db/action.go @@ -17,7 +17,7 @@ type MysqlAction struct { ActionIndex int Nonce uint64 Height uint64 - Created uint + Created uint64 GasAssetId uint64 TransferAssetId uint64 ActionType uint64 @@ -36,11 +36,12 @@ type MysqlAction struct { func InsertAction(data *MysqlAction, dbTx *sql.Tx) error { tName := GetTableNameHash("actions_hash", data.TxHash) - stmt, err := dbTx.Prepare(fmt.Sprintf("insert into %s (tx_hash, action_hash, action_index,nonce,height,created,gas_asset_id,transfer_asset_id,"+ - "action_type,from_account,to_account,amount,gas_limit,gas_used,state,error_msg,remark,payload,payload_size,internal_action_count) values (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)", tName)) + insertSql := fmt.Sprintf("insert into %s (tx_hash, action_hash, action_index,nonce,height,created,gas_asset_id,transfer_asset_id,"+ + "action_type,from_account,to_account,amount,gas_limit,gas_used,state,error_msg,remark,payload,payload_size,internal_action_count) values (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)", tName) + stmt, err := dbTx.Prepare(insertSql) defer stmt.Close() if err != nil { - ZapLog.Panic("InsertAction error", zap.Error(err), zap.String("txHash", data.TxHash)) + ZapLog.Panic("InsertAction error", zap.Error(err), zap.String("txHash", data.TxHash), zap.String("sql", insertSql)) } state := strconv.FormatUint(data.State, 10) _, err = stmt.Exec(data.TxHash, data.ActionHash, data.ActionIndex, data.Nonce, data.Height, data.Created, data.GasAssetId, data.TransferAssetId, diff --git a/db/balance.go b/db/balance.go index be172f7..1a94bf5 100644 --- a/db/balance.go +++ b/db/balance.go @@ -36,7 +36,7 @@ func GetAccountBalance(name string, assetId uint64, dbTx *sql.Tx) (*big.Int, err return data, nil } -func UpdateAccountBalance(name string, amount *big.Int, assetId uint64, updateHeight uint64, updateTime uint, dbTx *sql.Tx) error { +func UpdateAccountBalance(name string, amount *big.Int, assetId uint64, updateHeight uint64, updateTime uint64, dbTx *sql.Tx) error { tName := GetTableNameHash("balance_hash", name) updateSql := fmt.Sprintf("update %s set amount = '%s', update_height = %d, update_time = %d where account_name = '%s' and asset_id = %d", tName, amount.String(), updateHeight, updateTime, name, assetId) @@ -48,7 +48,7 @@ func UpdateAccountBalance(name string, amount *big.Int, assetId uint64, updateHe return nil } -func InsertAccountBalance(name string, amount *big.Int, assetId uint64, height uint64, updateTime uint, dbTx *sql.Tx) error { +func InsertAccountBalance(name string, amount *big.Int, assetId uint64, height uint64, updateTime uint64, dbTx *sql.Tx) error { tName := GetTableNameHash("balance_hash", name) insertSql := fmt.Sprintf("insert %s set account_name = '%s', asset_id = %d, amount = '%s', update_height = %d, update_time = %d", tName, name, assetId, amount.String(), height, updateTime) diff --git a/db/block.go b/db/block.go index b9d78b7..d27d468 100644 --- a/db/block.go +++ b/db/block.go @@ -10,10 +10,10 @@ import ( "go.uber.org/zap" ) -func InsertBlockChain(tx *sql.Tx, hd *types.Header, bhash types.Hash, fee *big.Int, txCount int) error { +func InsertBlockChain(tx *sql.Tx, hd *types.RpcBlock, bhash types.Hash, fee *big.Int, txCount int) error { tName := GetTableNameID1("block_id", hd.Number.Uint64()) blocksql := fmt.Sprintf("INSERT INTO %s(hash, parent_hash, height, created, gas_limit, gas_used, producer, tx_count ,fee) VALUES('%s','%s',%d,%d,%d,%d,'%s',%d,'%s');", - tName, bhash.String(), hd.ParentHash.String(), hd.Number.Int64(), hd.Time, hd.GasLimit, hd.GasUsed, hd.Coinbase.String(), txCount, fee.String()) + tName, bhash.String(), hd.ParentHash.String(), hd.Number.Int64(), hd.Time, hd.GasLimit, hd.GasUsed, hd.CoinBase.String(), txCount, fee.String()) _, err := tx.Exec(blocksql) if err != nil { ZapLog.Error("insert block failed", zap.String("sql", blocksql), zap.Error(err)) diff --git a/db/fee.go b/db/fee.go index 630390e..4f5d8a5 100644 --- a/db/fee.go +++ b/db/fee.go @@ -17,7 +17,7 @@ type MysqlFee struct { ActionIndex int FeeIndex int Height uint64 - Created uint + Created uint64 AssetId uint64 From string To string diff --git a/db/internal.go b/db/internal.go index da52464..62938c8 100644 --- a/db/internal.go +++ b/db/internal.go @@ -17,7 +17,7 @@ type MysqlInternal struct { ActionIndex int InternalIndex int Height uint64 - Created uint + Created uint64 AssetId uint64 ActionType uint64 From string diff --git a/db/token.go b/db/token.go index 9f8a687..a582d3b 100644 --- a/db/token.go +++ b/db/token.go @@ -18,14 +18,14 @@ type Token struct { ContractName string Description string CreateUser string - CreateTime uint + CreateTime uint64 AssetOwner string Founder string UpperLimit *big.Int Liquidity *big.Int CumulativeIssue *big.Int CumulativeDestruction *big.Int - UpdateTime uint + UpdateTime uint64 } func AddToken(tx *sql.Tx, token *Token) { diff --git a/dispatch/dispatch.go b/dispatch/dispatch.go index fa17b4d..a6efb5a 100644 --- a/dispatch/dispatch.go +++ b/dispatch/dispatch.go @@ -156,14 +156,14 @@ func (d *Dispatch) sendBlockToTask() { for { block := <-d.blockDataChan - if block.Block.Head.Number.Uint64() > d.batchTo { //the inverse calculation block + if block.Block.Number.Uint64() > d.batchTo { //the inverse calculation block if d.currentBlock == nil { d.currentBlock = block } else { - if d.currentBlock.Hash.String() != block.Block.Head.ParentHash.String() { + if d.currentBlock.Block.Hash.String() != block.Block.ParentHash.String() { d.currentBlock = block d.rollback() - ZapLog.Info("rollback success", zap.Uint64("height", block.Block.Head.Number.Uint64()-1)) + ZapLog.Info("rollback success", zap.Uint64("height", block.Block.Number.Uint64()-1)) continue } d.currentBlock = block @@ -179,8 +179,8 @@ func (d *Dispatch) sendBlockToTask() { taskDataChan <- taskData } d.checkTaskResult() - if block.Block.Head.Number.Int64()%config.Log.SyncBlockShowNumber == 0 { - ZapLog.Info("commit success", zap.Uint64("height", block.Block.Head.Number.Uint64())) + if block.Block.Number.Int64()%config.Log.SyncBlockShowNumber == 0 { + ZapLog.Info("commit success", zap.Uint64("height", block.Block.Number.Uint64())) } } }() @@ -215,7 +215,7 @@ func (d *Dispatch) rollback() { break } } - endHeight := d.currentBlock.Block.Head.Number.Uint64() - 1 + endHeight := d.currentBlock.Block.Number.Uint64() - 1 for ; ; endHeight-- { dbBlock := db.Mysql.GetBlockOriginalByHeight(endHeight) @@ -223,7 +223,7 @@ func (d *Dispatch) rollback() { if err != nil { ZapLog.Panic("rpc get block error", zap.Error(err)) } - if dbBlock.BlockHash != chainBlock.Hash.String() { + if dbBlock.BlockHash != chainBlock.Block.Hash.String() { rollbackData := &task.TaskChanData{ Block: BlobToBlock(dbBlock), Tx: nil, @@ -244,13 +244,13 @@ func (d *Dispatch) rollback() { } func (d *Dispatch) cacheBlock(blockData *task.TaskChanData) { - height := blockData.Block.Block.Head.Number.Uint64() + height := blockData.Block.Block.Number.Uint64() if height > d.batchTo { irreversible, err := client.GetDposIrreversible() if err != nil { ZapLog.Panic("cache block data error", zap.Error(err)) } - if blockData.Block.Block.Head.Number.Uint64() > irreversible.BftIrreversible { + if blockData.Block.Block.Number.Uint64() > irreversible.BftIrreversible { db.AddReversibleBlockCache(BlockToBlob(blockData.Block)) } } @@ -272,9 +272,9 @@ func BlockToBlob(block *types.BlockAndResult) *db.BlockOriginal { } result := &db.BlockOriginal{ BlockData: data, - Height: block.Block.Head.Number.Uint64(), - BlockHash: block.Hash.String(), - ParentHash: block.Block.Head.ParentHash.String(), + Height: block.Block.Number.Uint64(), + BlockHash: block.Block.Hash.String(), + ParentHash: block.Block.ParentHash.String(), } return result } diff --git a/dispatch/scanner.go b/dispatch/scanner.go index 4bce857..8690e82 100644 --- a/dispatch/scanner.go +++ b/dispatch/scanner.go @@ -119,7 +119,7 @@ func scanning(fromHeight, toHeight int64, blockDataChan chan *types.BlockAndResu case <-ctx.Done(): return case block := <-chSave: - currentHeight := block.Block.Head.Number.Int64() + currentHeight := block.Block.Number.Int64() ZapLog.Debug("get block data finished", zap.Int64("height", currentHeight)) if currentHeight%config.Log.SyncBlockShowNumber == 0 { ZapLog.Info("get block data finished", zap.Int64("height", currentHeight)) diff --git a/init/init.go b/init/init.go index 2b86642..63ab02f 100644 --- a/init/init.go +++ b/init/init.go @@ -89,11 +89,12 @@ func initChainConfig() { ZapLog.Error("GetChainConfig error: ", zap.Error(err)) panic(err) } - sTime, err := client.GetBlockTimeByNumber(1) + block, err := client.GetBlockByNumber(1) if err != nil { ZapLog.Error("GetBlockTimeByNumber error: ", zap.Error(err)) panic(err) } + sTime := block.Time / 1000000000 config.Chain = &config.ChainConfig{ FeeAssetId: uint64(0), ChainName: chainConfig.ChainName, diff --git a/task/account.go b/task/account.go index 73e5e2e..d6fc89e 100644 --- a/task/account.go +++ b/task/account.go @@ -9,7 +9,6 @@ import ( "github.com/browser/db" . "github.com/browser/log" "github.com/browser/types" - "github.com/ethereum/go-ethereum/common/hexutil" "go.uber.org/zap" "strings" ) @@ -18,7 +17,7 @@ type AccountTask struct { *Base } -func (a *AccountTask) ActionToAccount(action *types.RPCAction, dbTx *sql.Tx, block *types.Block, oldAccounts map[string]struct{}) error { +func (a *AccountTask) ActionToAccount(action *types.RPCAction, dbTx *sql.Tx, block *types.RpcBlock, oldAccounts map[string]struct{}) error { aType := action.Type payload, err := parsePayload(action) if err != nil { @@ -69,7 +68,7 @@ func (a *AccountTask) ActionToAccount(action *types.RPCAction, dbTx *sql.Tx, blo Threshold: 1, UpdateAuthorThreshold: 1, Permissions: string(authorText), - Created: block.Head.Time, + Created: block.Time, ContractCreated: 0, Description: arg.Description, } @@ -81,8 +80,8 @@ func (a *AccountTask) ActionToAccount(action *types.RPCAction, dbTx *sql.Tx, blo mAcct.AuthorVersion = authorVersion.String() mAcct.CodeHash = crypto.Keccak256Hash(nil).String() - if block.Head.Number.Uint64() == 0 { - mAcct.ContractCreated = block.Head.Time + if block.Number.Uint64() == 0 { + mAcct.ContractCreated = block.Time } err = db.InsertAccount(mAcct, dbTx) if err != nil { @@ -103,7 +102,7 @@ func (a *AccountTask) ActionToAccount(action *types.RPCAction, dbTx *sql.Tx, blo } mOldAccount := &db.MysqlAccountRollback{ Account: account, - Height: block.Head.Number.Uint64() - 1, + Height: block.Number.Uint64() - 1, } err = db.InsertAccountRollback(mOldAccount, dbTx) if err != nil { @@ -211,7 +210,7 @@ func (a *AccountTask) ActionToAccount(action *types.RPCAction, dbTx *sql.Tx, blo } mOldAccount := &db.MysqlAccountRollback{ Account: account, - Height: block.Head.Number.Uint64() - 1, + Height: block.Number.Uint64() - 1, } err = db.InsertAccountRollback(mOldAccount, dbTx) if err != nil { @@ -229,19 +228,14 @@ func (a *AccountTask) ActionToAccount(action *types.RPCAction, dbTx *sql.Tx, blo if len(action.Payload) != 0 { values := map[string]interface{}{ "contract_code": hex.EncodeToString(action.Payload), - "contract_created": block.Head.Time, + "contract_created": block.Time, } code, err := client.GetCode(action.To.String()) if err != nil { ZapLog.Error("GetCode failed", zap.String("name", action.To.String()), zap.Error(err)) return err } - bitCode, err := hexutil.Decode(code) - if err != nil { - ZapLog.Error("Decode failed", zap.String("name", action.To.String()), zap.Error(err)) - return err - } - values["code_hash"] = crypto.Keccak256Hash(bitCode).String() + values["code_hash"] = crypto.Keccak256Hash(code.Code).String() err = db.UpdateAccount(action.To.String(), values, dbTx) if err != nil { ZapLog.Error("CreateContract failed", zap.Error(err)) @@ -397,11 +391,11 @@ func (a *AccountTask) Start(data chan *TaskChanData, rollbackData chan *TaskChan for { select { case d := <-data: - if d.Block.Block.Head.Number.Uint64() >= a.startHeight { + if d.Block.Block.Number.Uint64() >= a.startHeight { a.init() err := a.analysisAccount(d.Block, a.Tx) if err != nil { - ZapLog.Error("AccountTask analysisAccount error: ", zap.Error(err), zap.Uint64("height", d.Block.Block.Head.Number.Uint64())) + ZapLog.Error("AccountTask analysisAccount error: ", zap.Error(err), zap.Uint64("height", d.Block.Block.Number.Uint64())) panic(err) } a.startHeight++ @@ -410,11 +404,11 @@ func (a *AccountTask) Start(data chan *TaskChanData, rollbackData chan *TaskChan result <- true case rd := <-rollbackData: a.startHeight-- - if a.startHeight == rd.Block.Block.Head.Number.Uint64() { + if a.startHeight == rd.Block.Block.Number.Uint64() { a.init() err := a.rollback(rd.Block, a.Tx) if err != nil { - ZapLog.Error("AccountTask rollback error: ", zap.Error(err), zap.Uint64("height", rd.Block.Block.Head.Number.Uint64())) + ZapLog.Error("AccountTask rollback error: ", zap.Error(err), zap.Uint64("height", rd.Block.Block.Number.Uint64())) panic(err) } a.commit() diff --git a/task/account_history.go b/task/account_history.go index 0054c84..cf6d913 100644 --- a/task/account_history.go +++ b/task/account_history.go @@ -32,7 +32,7 @@ func (a *AccountHistoryTask) analysisAccountHistory(data *types.BlockAndResult, ActionHash: action.ActionHash.String(), ActionIndex: j, TxType: aType, - Height: block.Head.Number.Uint64(), + Height: block.Number.Uint64(), } err := db.InsertAccountHistory(mAccountHistory, dbTx) if err != nil { @@ -50,7 +50,7 @@ func (a *AccountHistoryTask) analysisAccountHistory(data *types.BlockAndResult, ActionHash: action.ActionHash.String(), ActionIndex: j, TxType: aType, - Height: block.Head.Number.Uint64(), + Height: block.Number.Uint64(), } err := db.InsertAccountHistory(mAccountHistory, dbTx) if err != nil { @@ -83,7 +83,7 @@ func (a *AccountHistoryTask) analysisAccountHistory(data *types.BlockAndResult, ActionIndex: j, OtherIndex: k, TxType: aType, - Height: block.Head.Number.Uint64(), + Height: block.Number.Uint64(), } err := db.InsertAccountHistory(mAccountHistory, dbTx) if err != nil { @@ -102,7 +102,7 @@ func (a *AccountHistoryTask) analysisAccountHistory(data *types.BlockAndResult, ActionIndex: j, OtherIndex: k, TxType: aType, - Height: block.Head.Number.Uint64(), + Height: block.Number.Uint64(), } err := db.InsertAccountHistory(mAccountHistory, dbTx) if err != nil { @@ -125,7 +125,7 @@ func (a *AccountHistoryTask) analysisAccountHistory(data *types.BlockAndResult, ActionIndex: j, OtherIndex: k, TxType: aType, - Height: block.Head.Number.Uint64(), + Height: block.Number.Uint64(), } err := db.InsertAccountHistory(mAccountHistory, dbTx) if err != nil { @@ -140,7 +140,7 @@ func (a *AccountHistoryTask) analysisAccountHistory(data *types.BlockAndResult, func (a *AccountHistoryTask) rollback(data *types.BlockAndResult, dbTx *sql.Tx) error { block := data.Block - height := block.Head.Number.Uint64() + height := block.Number.Uint64() for _, tx := range block.Txs { for _, action := range tx.RPCActions { if action.From.String() != "" { @@ -196,11 +196,11 @@ func (a *AccountHistoryTask) Start(data chan *TaskChanData, rollbackData chan *T for { select { case d := <-data: - if d.Block.Block.Head.Number.Uint64() >= a.startHeight { + if d.Block.Block.Number.Uint64() >= a.startHeight { a.init() err := a.analysisAccountHistory(d.Block, a.Tx) if err != nil { - ZapLog.Error("ActionTask analysisAction error: ", zap.Error(err), zap.Uint64("height", d.Block.Block.Head.Number.Uint64())) + ZapLog.Error("ActionTask analysisAction error: ", zap.Error(err), zap.Uint64("height", d.Block.Block.Number.Uint64())) panic(err) } a.startHeight++ @@ -209,11 +209,11 @@ func (a *AccountHistoryTask) Start(data chan *TaskChanData, rollbackData chan *T result <- true case rd := <-rollbackData: a.startHeight-- - if a.startHeight == rd.Block.Block.Head.Number.Uint64() { + if a.startHeight == rd.Block.Block.Number.Uint64() { a.init() err := a.rollback(rd.Block, a.Tx) if err != nil { - ZapLog.Error("ActionTask rollback error: ", zap.Error(err), zap.Uint64("height", rd.Block.Block.Head.Number.Uint64())) + ZapLog.Error("ActionTask rollback error: ", zap.Error(err), zap.Uint64("height", rd.Block.Block.Number.Uint64())) panic(err) } a.commit() diff --git a/task/action.go b/task/action.go index d547763..998d8b0 100644 --- a/task/action.go +++ b/task/action.go @@ -34,8 +34,8 @@ func (a *ActionTask) analysisAction(data *types.BlockAndResult, dbTx *sql.Tx) er ActionHash: action.ActionHash.String(), ActionIndex: j, Nonce: action.Nonce, - Height: block.Head.Number.Uint64(), - Created: block.Head.Time, + Height: block.Number.Uint64(), + Created: block.Time, GasAssetId: tx.GasAssetID, TransferAssetId: action.AssetID, ActionType: uint64(action.Type), @@ -83,7 +83,7 @@ func (a *ActionTask) rollback(data *types.BlockAndResult, dbTx *sql.Tx) error { for _, tx := range data.Block.Txs { err := db.DeleteActionByTxHash(tx.Hash, dbTx) if err != nil { - ZapLog.Error("DeleteActionByTxHash error: ", zap.Error(err), zap.Uint64("height", data.Block.Head.Number.Uint64()), zap.String("txHash", tx.Hash.String())) + ZapLog.Error("DeleteActionByTxHash error: ", zap.Error(err), zap.Uint64("height", data.Block.Number.Uint64()), zap.String("txHash", tx.Hash.String())) return err } } @@ -95,11 +95,11 @@ func (a *ActionTask) Start(data chan *TaskChanData, rollbackData chan *TaskChanD for { select { case d := <-data: - if d.Block.Block.Head.Number.Uint64() >= a.startHeight { + if d.Block.Block.Number.Uint64() >= a.startHeight { a.init() err := a.analysisAction(d.Block, a.Tx) if err != nil { - ZapLog.Error("ActionTask analysisAction error: ", zap.Error(err), zap.Uint64("height", d.Block.Block.Head.Number.Uint64())) + ZapLog.Error("ActionTask analysisAction error: ", zap.Error(err), zap.Uint64("height", d.Block.Block.Number.Uint64())) panic(err) } a.startHeight++ @@ -108,11 +108,11 @@ func (a *ActionTask) Start(data chan *TaskChanData, rollbackData chan *TaskChanD result <- true case rd := <-rollbackData: a.startHeight-- - if a.startHeight == rd.Block.Block.Head.Number.Uint64() { + if a.startHeight == rd.Block.Block.Number.Uint64() { a.init() err := a.rollback(rd.Block, a.Tx) if err != nil { - ZapLog.Error("ActionTask rollback error: ", zap.Error(err), zap.Uint64("height", rd.Block.Block.Head.Number.Uint64())) + ZapLog.Error("ActionTask rollback error: ", zap.Error(err), zap.Uint64("height", rd.Block.Block.Number.Uint64())) panic(err) } a.commit() diff --git a/task/balance.go b/task/balance.go index 4a68ab0..6500f80 100644 --- a/task/balance.go +++ b/task/balance.go @@ -15,7 +15,7 @@ type BalanceTask struct { *Base } -func subBalance(from string, assetId uint64, value *big.Int, h uint64, ut uint, dbTx *sql.Tx) error { +func subBalance(from string, assetId uint64, value *big.Int, h uint64, ut uint64, dbTx *sql.Tx) error { balance, err := db.GetAccountBalance(from, assetId, dbTx) if err != nil { ZapLog.Error("GetAccountBalance error: ", zap.Error(err), zap.String("from", from)) @@ -34,7 +34,7 @@ func subBalance(from string, assetId uint64, value *big.Int, h uint64, ut uint, return nil } -func addBalance(to string, assetId uint64, value *big.Int, h uint64, ut uint, dbTx *sql.Tx) error { +func addBalance(to string, assetId uint64, value *big.Int, h uint64, ut uint64, dbTx *sql.Tx) error { balance, err := db.GetAccountBalance(to, assetId, dbTx) if err != nil && err != sql.ErrNoRows { ZapLog.Error("Transfer error: ", zap.Error(err), zap.String("to", to)) @@ -67,7 +67,7 @@ func (b *BalanceTask) analysisBalance(data *types.BlockAndResult, dbTx *sql.Tx) for j, at := range tx.RPCActions { actionReceipt := receipt.ActionResults[j] fee := big.NewInt(0).Mul(big.NewInt(0).SetUint64(actionReceipt.GasUsed), big.NewInt(0).SetUint64(tx.GasPrice.Uint64())) - if data.Block.Head.Number.Uint64() > 0 { + if data.Block.Number.Uint64() > 0 { if at.From.String() != "" && at.From.String() != config.Chain.ChainFeeName { changeBalance(balanceChangedMap, at.From.String(), tx.GasAssetID, fee, false) } @@ -81,7 +81,7 @@ func (b *BalanceTask) analysisBalance(data *types.BlockAndResult, dbTx *sql.Tx) changeBalance(balanceChangedMap, at.To.String(), at.AssetID, at.Amount, true) } } - if data.Block.Head.Number.Uint64() == 0 && at.Type == types.IssueAsset { + if data.Block.Number.Uint64() == 0 && at.Type == types.IssueAsset { payload, err := parsePayload(at) if err != nil { ZapLog.Error("parse payload error: ", zap.Error(err)) @@ -93,7 +93,7 @@ func (b *BalanceTask) analysisBalance(data *types.BlockAndResult, dbTx *sql.Tx) ZapLog.Error("GetAssetInfoByName error", zap.Error(err)) return err } - err = db.InsertAccountBalance(arg.Owner.String(), arg.Amount, assetInfo.AssetId, data.Block.Head.Number.Uint64(), data.Block.Head.Time, dbTx) + err = db.InsertAccountBalance(arg.Owner.String(), arg.Amount, assetInfo.AssetId, data.Block.Number.Uint64(), data.Block.Time, dbTx) if err != nil { ZapLog.Error("InsertAccountBalance error: ", zap.Error(err), zap.String("owner", arg.Owner.String())) return err @@ -114,8 +114,8 @@ func (b *BalanceTask) analysisBalance(data *types.BlockAndResult, dbTx *sql.Tx) } } bigZero := big.NewInt(0) - h := data.Block.Head.Number.Uint64() - ut := data.Block.Head.Time + h := data.Block.Number.Uint64() + ut := data.Block.Time for name, bs := range balanceChangedMap { for assetId, v := range bs { rs := v.Cmp(bigZero) @@ -180,7 +180,7 @@ func (b *BalanceTask) rollback(data *types.BlockAndResult, dbTx *sql.Tx) error { actionReceipt := receipt.ActionResults[j] fee := big.NewInt(0).Mul(big.NewInt(0).SetUint64(actionReceipt.GasUsed), big.NewInt(0).SetUint64(tx.GasPrice.Uint64())) if at.From.String() != "" && at.From.String() != config.Chain.ChainFeeName { - err := addBalance(at.From.String(), tx.GasAssetID, fee, data.Block.Head.Number.Uint64(), data.Block.Head.Time, dbTx) + err := addBalance(at.From.String(), tx.GasAssetID, fee, data.Block.Number.Uint64(), data.Block.Time, dbTx) if err != nil { ZapLog.Error("add fee error: ", zap.Error(err), zap.String("fee from", at.From.String())) return err @@ -210,8 +210,8 @@ func (b *BalanceTask) rollback(data *types.BlockAndResult, dbTx *sql.Tx) error { } } bigZero := big.NewInt(0) - h := data.Block.Head.Number.Uint64() - ut := data.Block.Head.Time + h := data.Block.Number.Uint64() + ut := data.Block.Time for name, bs := range balanceChangedMap { for assetId, v := range bs { rs := v.Cmp(bigZero) @@ -239,11 +239,11 @@ func (b *BalanceTask) Start(data chan *TaskChanData, rollbackData chan *TaskChan for { select { case d := <-data: - if d.Block.Block.Head.Number.Uint64() >= b.startHeight { + if d.Block.Block.Number.Uint64() >= b.startHeight { b.init() err := b.analysisBalance(d.Block, b.Tx) if err != nil { - ZapLog.Error("BalanceTask analysisBalance error: ", zap.Error(err), zap.Uint64("height", d.Block.Block.Head.Number.Uint64())) + ZapLog.Error("BalanceTask analysisBalance error: ", zap.Error(err), zap.Uint64("height", d.Block.Block.Number.Uint64())) panic(err) } b.startHeight++ @@ -252,11 +252,11 @@ func (b *BalanceTask) Start(data chan *TaskChanData, rollbackData chan *TaskChan result <- true case rd := <-rollbackData: b.startHeight-- - if rd.Block.Block.Head.Number.Uint64() == b.startHeight { + if rd.Block.Block.Number.Uint64() == b.startHeight { b.init() err := b.rollback(rd.Block, b.Tx) if err != nil { - ZapLog.Error("BalanceTask rollback error: ", zap.Error(err), zap.Uint64("height", rd.Block.Block.Head.Number.Uint64())) + ZapLog.Error("BalanceTask rollback error: ", zap.Error(err), zap.Uint64("height", rd.Block.Block.Number.Uint64())) panic(err) } b.commit() diff --git a/task/block.go b/task/block.go index 7f5d125..9fe8feb 100644 --- a/task/block.go +++ b/task/block.go @@ -18,7 +18,7 @@ type BlockTask struct { } func (b *BlockTask) analysisBlock(d *types.BlockAndResult, dbTx *sql.Tx) error { - height := d.Block.Head.Number.Uint64() + height := d.Block.Number.Uint64() blockFee := big.NewInt(0) txs := d.Block.Txs for i := 0; i < len(txs); i++ { @@ -31,16 +31,17 @@ func (b *BlockTask) analysisBlock(d *types.BlockAndResult, dbTx *sql.Tx) error { fee := big.NewInt(0).Mul(big.NewInt(0).SetUint64(receipt.TotalGasUsed), big.NewInt(0).SetUint64(txs[i].GasPrice.Uint64())) blockFee = blockFee.Add(blockFee, fee) } - err := db.InsertBlockChain(b.Tx, d.Block.Head, d.Hash, blockFee, len(txs)) + err := db.InsertBlockChain(b.Tx, d.Block, d.Block.Hash, blockFee, len(txs)) if err != nil { ZapLog.Panic("InsertBlockChain error: ", zap.Error(err), zap.Uint64("height", height)) return err } - h, _, err := client.GetCurrentBlockInfo() + cb, err := client.GetCurrentBlockInfo() if err != nil { ZapLog.Error("GetCurrentBlockInfo error", zap.Error(err)) return err } + h := cb.Number.Uint64() candidatesCount, err := client.GetCandidatesCount() if err != nil { ZapLog.Error("GetCandidatesCount error", zap.Error(err)) @@ -59,7 +60,7 @@ func (b *BlockTask) analysisBlock(d *types.BlockAndResult, dbTx *sql.Tx) error { } func (b *BlockTask) rollback(d *types.BlockAndResult, dbTx *sql.Tx) error { - height := d.Block.Head.Number.Uint64() + height := d.Block.Number.Uint64() err := db.DeleteBlock(b.Tx, height) if err != nil { ZapLog.Panic("DeleteBlock error: ", zap.Error(err), zap.Uint64("height", height)) @@ -86,11 +87,11 @@ func (b *BlockTask) Start(data chan *TaskChanData, rollbackData chan *TaskChanDa for { select { case d := <-data: - if d.Block.Block.Head.Number.Uint64() >= b.startHeight { + if d.Block.Block.Number.Uint64() >= b.startHeight { b.init() err := b.analysisBlock(d.Block, b.Tx) if err != nil { - ZapLog.Error("AccountTask analysisAccount error: ", zap.Error(err), zap.Uint64("height", d.Block.Block.Head.Number.Uint64())) + ZapLog.Error("AccountTask analysisAccount error: ", zap.Error(err), zap.Uint64("height", d.Block.Block.Number.Uint64())) panic(err) } b.startHeight++ @@ -99,11 +100,11 @@ func (b *BlockTask) Start(data chan *TaskChanData, rollbackData chan *TaskChanDa result <- true case rd := <-rollbackData: b.startHeight-- - if b.startHeight == rd.Block.Block.Head.Number.Uint64() { + if b.startHeight == rd.Block.Block.Number.Uint64() { b.init() err := b.rollback(rd.Block, b.Tx) if err != nil { - ZapLog.Error("AccountTask rollback error: ", zap.Error(err), zap.Uint64("height", rd.Block.Block.Head.Number.Uint64())) + ZapLog.Error("AccountTask rollback error: ", zap.Error(err), zap.Uint64("height", rd.Block.Block.Number.Uint64())) panic(err) } b.commit() diff --git a/task/fee.go b/task/fee.go index 060fc36..213eace 100644 --- a/task/fee.go +++ b/task/fee.go @@ -29,8 +29,8 @@ func (f *FeeTask) analysisFeeAction(data *types.BlockAndResult, dbTx *sql.Tx) er ActionHash: at.ActionHash.String(), ActionIndex: j, FeeIndex: k, - Height: data.Block.Head.Number.Uint64(), - Created: data.Block.Head.Time, + Height: data.Block.Number.Uint64(), + Created: data.Block.Time, AssetId: tx.GasAssetID, From: at.From.String(), To: aR.Account.String(), @@ -68,7 +68,7 @@ func (f *FeeTask) rollback(data *types.BlockAndResult, dbTx *sql.Tx) error { for j, at := range tx.RPCActions { err := db.DeleteFeeByActionHash(at.ActionHash, dbTx) if err != nil { - ZapLog.Error("DeleteFeeByActionHash error:", zap.Error(err), zap.Uint64("height", data.Block.Head.Number.Uint64())) + ZapLog.Error("DeleteFeeByActionHash error:", zap.Error(err), zap.Uint64("height", data.Block.Number.Uint64())) return err } aRs := data.Receipts[i].ActionResults[j].GasAllot @@ -105,11 +105,11 @@ func (f *FeeTask) Start(data chan *TaskChanData, rollbackData chan *TaskChanData for { select { case d := <-data: - if d.Block.Block.Head.Number.Uint64() >= f.startHeight { + if d.Block.Block.Number.Uint64() >= f.startHeight { f.init() err := f.analysisFeeAction(d.Block, f.Tx) if err != nil { - ZapLog.Error("FeeTask analysisFeeAction error: ", zap.Error(err), zap.Uint64("height", d.Block.Block.Head.Number.Uint64())) + ZapLog.Error("FeeTask analysisFeeAction error: ", zap.Error(err), zap.Uint64("height", d.Block.Block.Number.Uint64())) panic(err) } f.startHeight++ @@ -118,11 +118,11 @@ func (f *FeeTask) Start(data chan *TaskChanData, rollbackData chan *TaskChanData result <- true case rd := <-rollbackData: f.startHeight-- - if f.startHeight == rd.Block.Block.Head.Number.Uint64() { + if f.startHeight == rd.Block.Block.Number.Uint64() { f.init() err := f.rollback(rd.Block, f.Tx) if err != nil { - ZapLog.Error("ActionTask rollback error: ", zap.Error(err), zap.Uint64("height", rd.Block.Block.Head.Number.Uint64())) + ZapLog.Error("ActionTask rollback error: ", zap.Error(err), zap.Uint64("height", rd.Block.Block.Number.Uint64())) panic(err) } f.commit() diff --git a/task/internal.go b/task/internal.go index 1c09251..cd2b064 100644 --- a/task/internal.go +++ b/task/internal.go @@ -28,8 +28,8 @@ func (i *InternalTask) analysisInternalAction(data *types.BlockAndResult, dbTx * ActionHash: a.ActionHash.String(), ActionIndex: j, InternalIndex: k, - Height: data.Block.Head.Number.Uint64(), - Created: data.Block.Head.Time, + Height: data.Block.Number.Uint64(), + Created: data.Block.Time, AssetId: ia.Action.AssetID, ActionType: uint64(ia.Action.Type), From: ia.Action.From.String(), @@ -77,7 +77,7 @@ func (i *InternalTask) rollback(data *types.BlockAndResult, dbTx *sql.Tx) error for _, at := range tx.RPCActions { err := db.DeleteInternalByActionHash(at.ActionHash, dbTx) if err != nil { - ZapLog.Error("DeleteInternalByActionHash error:", zap.Error(err), zap.Uint64("height", data.Block.Head.Number.Uint64())) + ZapLog.Error("DeleteInternalByActionHash error:", zap.Error(err), zap.Uint64("height", data.Block.Number.Uint64())) return err } } @@ -91,11 +91,11 @@ func (i *InternalTask) Start(data chan *TaskChanData, rollbackData chan *TaskCha for { select { case d := <-data: - if d.Block.Block.Head.Number.Uint64() >= i.startHeight { + if d.Block.Block.Number.Uint64() >= i.startHeight { i.init() err := i.analysisInternalAction(d.Block, i.Tx) if err != nil { - ZapLog.Error("InternalTask analysisInternalAction error: ", zap.Error(err), zap.Uint64("height", d.Block.Block.Head.Number.Uint64())) + ZapLog.Error("InternalTask analysisInternalAction error: ", zap.Error(err), zap.Uint64("height", d.Block.Block.Number.Uint64())) panic(err) } i.startHeight++ @@ -104,11 +104,11 @@ func (i *InternalTask) Start(data chan *TaskChanData, rollbackData chan *TaskCha result <- true case rd := <-rollbackData: i.startHeight-- - if rd.Block.Block.Head.Number.Uint64() >= i.startHeight { + if rd.Block.Block.Number.Uint64() >= i.startHeight { i.init() err := i.rollback(rd.Block, i.Tx) if err != nil { - ZapLog.Error("InternalTask rollback error: ", zap.Error(err), zap.Uint64("height", rd.Block.Block.Head.Number.Uint64())) + ZapLog.Error("InternalTask rollback error: ", zap.Error(err), zap.Uint64("height", rd.Block.Block.Number.Uint64())) panic(err) } i.commit() diff --git a/task/token.go b/task/token.go index 4a258d3..389186f 100644 --- a/task/token.go +++ b/task/token.go @@ -21,7 +21,7 @@ func (t *TokenTask) Start(data chan *TaskChanData, rollbackData chan *TaskChanDa for { select { case block := <-data: - if block.Block.Block.Head.Number.Uint64() >= t.startHeight { + if block.Block.Block.Number.Uint64() >= t.startHeight { t.init() block.Tx = t.Tx t.analysisToken(block) @@ -31,7 +31,7 @@ func (t *TokenTask) Start(data chan *TaskChanData, rollbackData chan *TaskChanDa result <- true case block := <-rollbackData: t.startHeight-- - if t.startHeight == block.Block.Block.Head.Number.Uint64() { + if t.startHeight == block.Block.Block.Number.Uint64() { t.init() block.Tx = t.Tx t.rollback(block) @@ -84,7 +84,7 @@ func (t *TokenTask) analysisToken(block *TaskChanData) { isbackup = 1 } } - saveToken(block.Tx, action, block.Block.Block.Head.Time, block.Block.Block.Head.Number.Uint64(), isbackup) + saveToken(block.Tx, action, block.Block.Block.Time, block.Block.Block.Number.Uint64(), isbackup) } } } @@ -105,7 +105,7 @@ func (t *TokenTask) analysisToken(block *TaskChanData) { isbackup = 1 } } - saveToken(block.Tx, internalLog.Action, block.Block.Block.Head.Time, block.Block.Block.Head.Number.Uint64(), isbackup) + saveToken(block.Tx, internalLog.Action, block.Block.Block.Time, block.Block.Block.Number.Uint64(), isbackup) } } } @@ -121,7 +121,7 @@ func (t *TokenTask) rollback(block *TaskChanData) { for j, action := range tx.RPCActions { if receipts[i].ActionResults[j].Status == types.ReceiptStatusSuccessful { if t.isTokenTxs(action.Type) { - rollbackToken(block.Tx, action, block.Block.Block.Head.Time, block.Block.Block.Head.Number.Uint64()) + rollbackToken(block.Tx, action, block.Block.Block.Time, block.Block.Block.Number.Uint64()) } } } @@ -134,7 +134,7 @@ func (t *TokenTask) rollback(block *TaskChanData) { if receipts[i].ActionResults[j].Status == types.ReceiptStatusSuccessful { for _, internalLog := range action.InternalLogs { if t.isTokenTxs(internalLog.Action.Type) { - rollbackToken(block.Tx, internalLog.Action, block.Block.Block.Head.Time, block.Block.Block.Head.Number.Uint64()) + rollbackToken(block.Tx, internalLog.Action, block.Block.Block.Time, block.Block.Block.Number.Uint64()) } } } @@ -143,7 +143,7 @@ func (t *TokenTask) rollback(block *TaskChanData) { } } -func saveToken(tx *sql.Tx, action *types.RPCAction, blockTime uint, height uint64, backup int) { +func saveToken(tx *sql.Tx, action *types.RPCAction, blockTime uint64, height uint64, backup int) { iActionAsset, _ := parsePayload(action) if action.Type == types.IssueAsset { obj := iActionAsset.(types.IssueAssetObject) @@ -226,7 +226,7 @@ func saveToken(tx *sql.Tx, action *types.RPCAction, blockTime uint, height uint6 } } -func rollbackToken(tx *sql.Tx, action *types.RPCAction, blockTime uint, height uint64) { +func rollbackToken(tx *sql.Tx, action *types.RPCAction, blockTime uint64, height uint64) { iActionAsset, _ := parsePayload(action) if action.Type == types.IssueAsset { obj := iActionAsset.(types.IssueAssetObject) diff --git a/task/token_fee_history.go b/task/token_fee_history.go index 56838c2..418f700 100644 --- a/task/token_fee_history.go +++ b/task/token_fee_history.go @@ -34,7 +34,7 @@ func (f *TokenFeeHistoryTask) analysis(data *types.BlockAndResult, dbTx *sql.Tx) ActionIndex: j, ActionHash: at.ActionHash.String(), FeeActionIndex: k, - Height: data.Block.Head.Number.Uint64(), + Height: data.Block.Number.Uint64(), } err = db.InsertTokenFeeHistory(mTFH, dbTx) if err != nil { @@ -55,9 +55,9 @@ func (a *TokenFeeHistoryTask) rollback(data *types.BlockAndResult, dbTx *sql.Tx) for _, aR := range aRs.GasAllot { if aR.Reason == 0 { tokenInfo := db.QueryTokenByName(dbTx, aR.Account.String()) - err := db.DeleteTokenFeeHistoryByHeight(tokenInfo.AssetId, data.Block.Head.Number.Uint64(), dbTx) + err := db.DeleteTokenFeeHistoryByHeight(tokenInfo.AssetId, data.Block.Number.Uint64(), dbTx) if err != nil { - ZapLog.Error("DeleteTokenFeeHistoryByHeight", zap.Error(err), zap.Uint64("height", data.Block.Head.Number.Uint64())) + ZapLog.Error("DeleteTokenFeeHistoryByHeight", zap.Error(err), zap.Uint64("height", data.Block.Number.Uint64())) return err } } @@ -72,11 +72,11 @@ func (a *TokenFeeHistoryTask) Start(data chan *TaskChanData, rollbackData chan * for { select { case d := <-data: - if d.Block.Block.Head.Number.Uint64() >= a.startHeight { + if d.Block.Block.Number.Uint64() >= a.startHeight { a.init() err := a.analysis(d.Block, a.Tx) if err != nil { - ZapLog.Error("TokenFeeHistoryTask analysis error: ", zap.Error(err), zap.Uint64("height", d.Block.Block.Head.Number.Uint64())) + ZapLog.Error("TokenFeeHistoryTask analysis error: ", zap.Error(err), zap.Uint64("height", d.Block.Block.Number.Uint64())) panic(err) } a.startHeight++ @@ -85,11 +85,11 @@ func (a *TokenFeeHistoryTask) Start(data chan *TaskChanData, rollbackData chan * result <- true case rd := <-rollbackData: a.startHeight-- - if rd.Block.Block.Head.Number.Uint64() == a.startHeight { + if rd.Block.Block.Number.Uint64() == a.startHeight { a.init() err := a.rollback(rd.Block, a.Tx) if err != nil { - ZapLog.Error("TokenFeeHistoryTask rollback error: ", zap.Error(err), zap.Uint64("height", rd.Block.Block.Head.Number.Uint64())) + ZapLog.Error("TokenFeeHistoryTask rollback error: ", zap.Error(err), zap.Uint64("height", rd.Block.Block.Number.Uint64())) panic(err) } a.commit() diff --git a/task/token_history.go b/task/token_history.go index ac0e7d0..1ddd50b 100644 --- a/task/token_history.go +++ b/task/token_history.go @@ -52,7 +52,7 @@ func (t *TokeHistoryTask) analysisTokenHistory(data *types.BlockAndResult, dbTx ActionHash: aT.ActionHash.String(), TxType: 0, ActionType: uint64(aT.Type), - Height: block.Head.Number.Uint64(), + Height: block.Number.Uint64(), } err = db.InsertTokenHistory(mTH, dbTx) if err != nil { @@ -91,7 +91,7 @@ func (t *TokeHistoryTask) analysisTokenHistory(data *types.BlockAndResult, dbTx InternalIndex: k, TxType: 1, ActionType: uint64(iAt.Action.Type), - Height: block.Head.Number.Uint64(), + Height: block.Number.Uint64(), } err = db.InsertTokenHistory(mTH, dbTx) if err != nil { @@ -107,7 +107,7 @@ func (t *TokeHistoryTask) analysisTokenHistory(data *types.BlockAndResult, dbTx } func (t *TokeHistoryTask) rollback(data *types.BlockAndResult, dbTx *sql.Tx) error { - return db.DeleteTokenHistoryByHeight(data.Block.Head.Number.Uint64(), dbTx) + return db.DeleteTokenHistoryByHeight(data.Block.Number.Uint64(), dbTx) } func (t *TokeHistoryTask) Start(data chan *TaskChanData, rollbackData chan *TaskChanData, result chan bool, startHeight uint64) { @@ -115,11 +115,11 @@ func (t *TokeHistoryTask) Start(data chan *TaskChanData, rollbackData chan *Task for { select { case d := <-data: - if d.Block.Block.Head.Number.Uint64() >= t.startHeight { + if d.Block.Block.Number.Uint64() >= t.startHeight { t.init() err := t.analysisTokenHistory(d.Block, t.Tx) if err != nil { - ZapLog.Error("ActionTask analysisAction error: ", zap.Error(err), zap.Uint64("height", d.Block.Block.Head.Number.Uint64())) + ZapLog.Error("ActionTask analysisAction error: ", zap.Error(err), zap.Uint64("height", d.Block.Block.Number.Uint64())) panic(err) } t.startHeight++ @@ -128,11 +128,11 @@ func (t *TokeHistoryTask) Start(data chan *TaskChanData, rollbackData chan *Task result <- true case rd := <-rollbackData: t.startHeight-- - if t.startHeight == rd.Block.Block.Head.Number.Uint64() { + if t.startHeight == rd.Block.Block.Number.Uint64() { t.init() err := t.rollback(rd.Block, t.Tx) if err != nil { - ZapLog.Error("ActionTask rollback error: ", zap.Error(err), zap.Uint64("height", rd.Block.Block.Head.Number.Uint64())) + ZapLog.Error("ActionTask rollback error: ", zap.Error(err), zap.Uint64("height", rd.Block.Block.Number.Uint64())) panic(err) } t.commit() diff --git a/task/transaction.go b/task/transaction.go index 0935f0a..fd64f5b 100644 --- a/task/transaction.go +++ b/task/transaction.go @@ -22,12 +22,12 @@ func (b *TransactionTask) analysisTransaction(data *types.BlockAndResult, dbTx * receipt := receipts[i] mTx := &db.MysqlTx{ Hash: tx.Hash.String(), - Height: block.Head.Number.Uint64(), + Height: block.Number.Uint64(), GasUsed: receipt.TotalGasUsed, GasCost: tx.GasCost, GasPrice: tx.GasPrice, GasAssetId: tx.GasAssetID, - BlockHash: data.Hash.String(), + BlockHash: data.Block.Hash.String(), TxIndex: i, ActionCount: len(tx.RPCActions), } @@ -40,7 +40,7 @@ func (b *TransactionTask) analysisTransaction(data *types.BlockAndResult, dbTx * mTx.State = state err := db.InsertTransaction(mTx, dbTx) if err != nil { - ZapLog.Error("InsertTransaction error: ", zap.Error(err), zap.Uint64("height", block.Head.Number.Uint64()), zap.Int("txIndex", i)) + ZapLog.Error("InsertTransaction error: ", zap.Error(err), zap.Uint64("height", block.Number.Uint64()), zap.Int("txIndex", i)) return err } fee := big.NewInt(0).Mul(big.NewInt(0).SetUint64(mTx.GasUsed), mTx.GasPrice) @@ -64,7 +64,7 @@ func (b *TransactionTask) rollback(data *types.BlockAndResult, dbTx *sql.Tx) err receipt := data.Receipts[i] err := db.DeleteTransactionByHash(tx.Hash, dbTx) if err != nil { - ZapLog.Error("DeleteTransactionByHash error: ", zap.Error(err), zap.Uint64("height", data.Block.Head.Number.Uint64()), zap.String("txHash", tx.Hash.String())) + ZapLog.Error("DeleteTransactionByHash error: ", zap.Error(err), zap.Uint64("height", data.Block.Number.Uint64()), zap.String("txHash", tx.Hash.String())) return err } fee := big.NewInt(0).Mul(big.NewInt(0).SetUint64(receipt.TotalGasUsed), tx.GasPrice) @@ -94,11 +94,11 @@ func (b *TransactionTask) Start(data chan *TaskChanData, rollbackData chan *Task for { select { case d := <-data: - if d.Block.Block.Head.Number.Uint64() >= b.startHeight { + if d.Block.Block.Number.Uint64() >= b.startHeight { b.init() err := b.analysisTransaction(d.Block, b.Tx) if err != nil { - ZapLog.Error("TransactionTask analysisBlock error: ", zap.Error(err), zap.Uint64("height", d.Block.Block.Head.Number.Uint64())) + ZapLog.Error("TransactionTask analysisBlock error: ", zap.Error(err), zap.Uint64("height", d.Block.Block.Number.Uint64())) panic(err) } b.startHeight++ @@ -107,11 +107,11 @@ func (b *TransactionTask) Start(data chan *TaskChanData, rollbackData chan *Task result <- true case rd := <-rollbackData: b.startHeight-- - if b.startHeight == rd.Block.Block.Head.Number.Uint64() { + if b.startHeight == rd.Block.Block.Number.Uint64() { b.init() err := b.rollback(rd.Block, b.Tx) if err != nil { - ZapLog.Error("TransactionTask analysisBlock error: ", zap.Error(err), zap.Uint64("height", rd.Block.Block.Head.Number.Uint64())) + ZapLog.Error("TransactionTask analysisBlock error: ", zap.Error(err), zap.Uint64("height", rd.Block.Block.Number.Uint64())) panic(err) } b.commit() diff --git a/types/account.go b/types/account.go index 217be13..23ad88b 100644 --- a/types/account.go +++ b/types/account.go @@ -1,6 +1,7 @@ package types import ( + "github.com/ethereum/go-ethereum/common/hexutil" "math/big" ) @@ -32,7 +33,7 @@ type Account struct { AccountID uint64 `json:"accountID"` Number uint64 `json:"number"` Nonce uint64 `json:"nonce"` - Code []byte `json:"code"` + Code hexutil.Bytes `json:"code"` CodeHash Hash `json:"codeHash"` CodeSize uint64 `json:"codeSize"` Threshold uint64 `json:"threshold"` @@ -44,3 +45,7 @@ type Account struct { Destroy bool `json:"destroy"` Description string `json:"description"` } + +type Code struct { + Code hexutil.Bytes `json:"code"` +} diff --git a/types/action.go b/types/action.go index 22ff7eb..ba85b74 100644 --- a/types/action.go +++ b/types/action.go @@ -92,15 +92,15 @@ var ActionTypeToString map[ActionType]string = map[ActionType]string{ } type RPCAction struct { - Type ActionType `json:"type"` - Nonce uint64 `json:"nonce"` - From Name `json:"from"` - To Name `json:"to"` - AssetID uint64 `json:"assetID"` - GasLimit uint64 `json:"gas"` - Amount *big.Int `json:"value"` - Remark hexutil.Bytes `json:"remark"` - Payload hexutil.Bytes `json:"payload"` - //PayloadParsed interface{} `json:"payload_parsed"` - ActionHash Hash `json:"action_hash"` + Type ActionType `json:"type"` + Nonce uint64 `json:"nonce"` + From Name `json:"from"` + To Name `json:"to"` + AssetID uint64 `json:"assetID"` + GasLimit uint64 `json:"gas"` + Amount *big.Int `json:"value"` + Remark hexutil.Bytes `json:"remark"` + Payload hexutil.Bytes `json:"payload"` + ActionHash Hash `json:"actionHash"` + ActionIndex uint64 `json:"actionIndex"` } diff --git a/types/author.go b/types/author.go index 674044c..ac1049c 100644 --- a/types/author.go +++ b/types/author.go @@ -2,8 +2,10 @@ package types import ( "encoding/hex" + "encoding/json" "errors" "github.com/browser/rlp" + "github.com/fractalplatform/fractal/common" "io" "strings" ) @@ -170,6 +172,43 @@ func (a *Author) decode(sa *StorageAuthor) error { return errors.New("author decode failed") } +type AuthorJSON struct { + authorType AuthorType + OwnerStr string `json:"owner"` + Weight uint64 `json:"weight"` +} + +func (a *Author) MarshalJSON() ([]byte, error) { + switch aTy := a.Owner.(type) { + case Name: + return json.Marshal(&AuthorJSON{authorType: AccountNameType, OwnerStr: aTy.String(), Weight: a.Weight}) + case PubKey: + return json.Marshal(&AuthorJSON{authorType: PubKeyType, OwnerStr: aTy.String(), Weight: a.Weight}) + case Address: + return json.Marshal(&AuthorJSON{authorType: AddressType, OwnerStr: aTy.String(), Weight: a.Weight}) + } + return nil, errors.New("Author marshal failed") +} + +func (a *Author) UnmarshalJSON(data []byte) error { + aj := &AuthorJSON{} + if err := json.Unmarshal(data, aj); err != nil { + return err + } + switch aj.authorType { + case AccountNameType: + a.Owner = Name(aj.OwnerStr) + a.Weight = aj.Weight + case PubKeyType: + a.Owner = HexToPubKey(aj.OwnerStr) + a.Weight = aj.Weight + case AddressType: + a.Owner = common.HexToAddress(aj.OwnerStr) + a.Weight = aj.Weight + } + return nil +} + var ( AuthorTypeToString map[AuthorType]string = map[AuthorType]string{ AccountNameType: "account", diff --git a/types/block.go b/types/block.go index d271227..de9d6a5 100644 --- a/types/block.go +++ b/types/block.go @@ -4,26 +4,27 @@ import ( "fmt" "github.com/browser/common" "github.com/browser/rlp" + "github.com/ethereum/go-ethereum/common/hexutil" "math/big" ) -// Header represents a block header in the block chain. -type Header struct { - ParentHash Hash `json:"parentHash"` - Coinbase Name `json:"miner"` - Difficulty *big.Int `json:"difficulty"` - Number *big.Int `json:"number"` - GasLimit uint64 `json:"gasLimit"` - GasUsed uint64 `json:"gasUsed"` - Time uint `json:"timestamp"` - Extra []byte `json:"extraData"` -} - -// Block represents an entire block in the block chain. -type Block struct { - Head *Header - Txs []*RPCTransaction -} +//// Header represents a block header in the block chain. +//type Header struct { +// ParentHash Hash `json:"parentHash"` +// Coinbase Name `json:"miner"` +// Difficulty *big.Int `json:"difficulty"` +// Number *big.Int `json:"number"` +// GasLimit uint64 `json:"gasLimit"` +// GasUsed uint64 `json:"gasUsed"` +// Time uint `json:"timestamp"` +// Extra []byte `json:"extraData"` +//} +// +//// Block represents an entire block in the block chain. +//type Block struct { +// Head *Header +// Txs []*RPCTransaction +//} func RlpHash(x interface{}) (h Hash) { hw := common.Get256() @@ -35,3 +36,43 @@ func RlpHash(x interface{}) (h Hash) { hw.Sum(h[:0]) return h } + +type ForkID struct { + Cur uint64 `json:"cur"` + Next uint64 `json:"next"` +} + +const BloomByteLength = 256 + +type Bloom [BloomByteLength]byte + +// MarshalText encodes b as a hex string with 0x prefix. +func (b Bloom) MarshalText() ([]byte, error) { + return hexutil.Bytes(b[:]).MarshalText() +} + +// UnmarshalText b as a hex string with 0x prefix. +func (b *Bloom) UnmarshalText(input []byte) error { + return hexutil.UnmarshalFixedText("Bloom", input, b[:]) +} + +type RpcBlock struct { + Number *big.Int `json:"number"` + Hash Hash `json:"hash"` + ProposedIrreversible uint64 `json:"proposedIrreversible"` + ParentHash Hash `json:"parentHash"` + Bloom Bloom `json:"logsBloom"` + Root Hash `json:"stateRoot"` + CoinBase Name `json:"miner"` + Difficulty *big.Int `json:"difficulty"` + Extra []byte `json:"extraData"` + Size uint64 `json:"size"` + GasLimit uint64 `json:"gasLimit"` + GasUsed uint64 `json:"gasUsed"` + Time uint64 `json:"timestamp"` + TxsRoot Hash `json:"transactionsRoot"` + ReceiptsRoot Hash `json:"receiptsRoot"` + ForkID ForkID `json:"forkID"` + TotalDifficulty *big.Int `json:"totalDifficulty"` + Txs []*RPCTransaction `json:"transactions"` +} diff --git a/types/receipt.go b/types/receipt.go index 46b3318..58c3d13 100644 --- a/types/receipt.go +++ b/types/receipt.go @@ -1,8 +1,6 @@ package types -import ( - "math/big" -) +import "math/big" const ( // ReceiptStatusFailed is the status code of a action if execution failed. @@ -14,29 +12,28 @@ const ( //Reason 0 asset 1 contract 2 produce type GasDistribution struct { - Account Name `json:"account"` - Gas uint64 `json:"gas"` - Reason uint64 - //Fromaccount string + Account Name `json:"name"` + Gas uint64 `json:"gas"` + Reason uint64 `json:"typeId"` } // ActionResult represents the results the transaction action. type ActionResult struct { - GasAllot []*GasDistribution - Status uint64 + GasAllot []*GasDistribution `json:"GasAllot"` + Status uint64 `json:"Status"` + GasUsed uint64 `json:"GasUsed"` + Error string `json:"Error"` // Index uint64 - GasUsed uint64 - Error string } // Receipt represents the results of a transaction. type Receipt struct { - // PostState []byte - ActionResults []*ActionResult - CumulativeGasUsed uint64 - // Logs []*Log - TxHash Hash - TotalGasUsed uint64 + PostState []byte `json:"PostState"` + ActionResults []*ActionResult `json:"ActionResults"` + CumulativeGasUsed uint64 `json:"CumulativeGasUsed"` + TxHash Hash `json:"TxHash"` + TotalGasUsed uint64 `json:"TotalGasUsed"` + //Logs []*Log } func (g *GasDistribution) NewRpcAction() *RPCAction { diff --git a/types/rpcresult.go b/types/rpcresult.go index 03d7248..378ebb2 100644 --- a/types/rpcresult.go +++ b/types/rpcresult.go @@ -1,26 +1,25 @@ package types type DetailTx struct { - TxHash Hash - InternalActions []*InternalAction + TxHash Hash `json:"txhash"` + InternalActions []*InternalAction `json:"actions"` } type InternalAction struct { - InternalLogs []*InternalLog + InternalLogs []*InternalLog `json:"internalActions"` } type InternalLog struct { - Action *RPCAction - ActionType string - GasUsed uint64 - GasLimit uint64 - Depth uint64 - Error string + Action *RPCAction `json:"action"` + ActionType string `json:"actionType"` + GasUsed uint64 `json:"gasUsed"` + GasLimit uint64 `json:"gasLimit"` + Depth uint64 `json:"depth"` + Error string `json:"error"` } type BlockAndResult struct { - Hash Hash - Block *Block - Receipts []*Receipt - DetailTxs []*DetailTx + Block *RpcBlock `json:"block"` + Receipts []*Receipt `json:"receipts"` + DetailTxs []*DetailTx `json:"detailTxs"` } diff --git a/types/transaction.go b/types/transaction.go index 02dbe4b..eaa43dd 100644 --- a/types/transaction.go +++ b/types/transaction.go @@ -4,10 +4,21 @@ import ( "math/big" ) +//type RPCTransaction struct { +// RPCActions []*RPCAction `json:"actions"` +// GasAssetID uint64 `json:"gasAssetID"` +// GasPrice *big.Int `json:"gasPrice"` +// GasCost *big.Int `json:"gasCost"` +// Hash Hash `json:"txHash"` +//} + type RPCTransaction struct { - RPCActions []*RPCAction `json:"actions"` - GasAssetID uint64 `json:"gasAssetID"` - GasPrice *big.Int `json:"gasPrice"` - GasCost *big.Int `json:"gasCost"` - Hash Hash `json:"txhash"` + BlockHash Hash `json:"blockHash"` + BlockNumber uint64 `json:"blockNumber"` + Hash Hash `json:"txHash"` + TransactionIndex uint64 `json:"transactionIndex"` + RPCActions []*RPCAction `json:"actions"` + GasAssetID uint64 `json:"gasAssetID"` + GasPrice *big.Int `json:"gasPrice"` + GasCost *big.Int `json:"gasCost"` }