From 38fcd08cc1d1e61fee21b4ac68fd6f536d4becdd Mon Sep 17 00:00:00 2001 From: Eric Mokaya Date: Mon, 20 Jan 2025 20:05:25 +0300 Subject: [PATCH 01/16] feat: create skeleton pattern --- actors/account.go | 45 ++---------- actors/account/account.go | 32 +++++++++ actors/account/authenticate.go | 43 ++++++++++++ actors/actor.go | 2 +- actors/cron/constructor.go | 39 +++++++++++ actors/cron/cron.go | 10 +++ actors/datacap/allowance.go | 124 +++++++++++++++++++++++++++++++++ actors/datacap/burn.go | 94 +++++++++++++++++++++++++ actors/datacap/datacap.go | 49 +++++++++++++ actors/datacap/granularity.go | 29 ++++++++ actors/datacap/mint.go | 39 +++++++++++ actors/datacap/transfer.go | 67 ++++++++++++++++++ 12 files changed, 531 insertions(+), 42 deletions(-) create mode 100644 actors/account/account.go create mode 100644 actors/account/authenticate.go create mode 100644 actors/cron/constructor.go create mode 100644 actors/cron/cron.go create mode 100644 actors/datacap/allowance.go create mode 100644 actors/datacap/burn.go create mode 100644 actors/datacap/datacap.go create mode 100644 actors/datacap/granularity.go create mode 100644 actors/datacap/mint.go create mode 100644 actors/datacap/transfer.go diff --git a/actors/account.go b/actors/account.go index 92b4ec47..b7870f65 100644 --- a/actors/account.go +++ b/actors/account.go @@ -1,59 +1,22 @@ package actors import ( - "bytes" - "encoding/base64" + "github.com/zondax/fil-parser/actors/account" "github.com/zondax/fil-parser/parser" - - "github.com/filecoin-project/go-address" - "github.com/filecoin-project/go-state-types/builtin/v11/account" - typegen "github.com/whyrusleeping/cbor-gen" ) -func (p *ActorParser) ParseAccount(txType string, msg *parser.LotusMessage, msgRct *parser.LotusMessageReceipt) (map[string]interface{}, error) { +func (p *ActorParser) ParseAccount(height int64, txType string, msg *parser.LotusMessage, msgRct *parser.LotusMessageReceipt) (map[string]interface{}, error) { switch txType { case parser.MethodSend: return p.parseSend(msg), nil case parser.MethodConstructor: return p.parseConstructor(msg.Params) case parser.MethodPubkeyAddress: - return p.pubkeyAddress(msg.Params, msgRct.Return) + return account.PubkeyAddress(msg.Params, msgRct.Return) case parser.MethodAuthenticateMessage: - return p.authenticateMessage(msg.Params, msgRct.Return) + return account.AuthenticateMessage(height, msg.Params, msgRct.Return) case parser.UnknownStr: return p.unknownMetadata(msg.Params, msgRct.Return) } return map[string]interface{}{}, parser.ErrUnknownMethod } - -func (p *ActorParser) pubkeyAddress(raw, rawReturn []byte) (map[string]interface{}, error) { - metadata := make(map[string]interface{}) - metadata[parser.ParamsKey] = base64.StdEncoding.EncodeToString(raw) - reader := bytes.NewReader(rawReturn) - var r address.Address - err := r.UnmarshalCBOR(reader) - if err != nil { - return metadata, err - } - metadata[parser.ReturnKey] = r.String() - return metadata, nil -} - -func (p *ActorParser) authenticateMessage(raw, rawReturn []byte) (map[string]interface{}, error) { - metadata := make(map[string]interface{}) - reader := bytes.NewReader(raw) - var params account.AuthenticateMessageParams - err := params.UnmarshalCBOR(reader) - if err != nil { - return metadata, err - } - metadata[parser.ParamsKey] = params - reader = bytes.NewReader(rawReturn) - var expiredReturn typegen.CborBool - err = expiredReturn.UnmarshalCBOR(reader) - if err != nil { - return metadata, err - } - metadata[parser.ReturnKey] = expiredReturn - return metadata, nil -} diff --git a/actors/account/account.go b/actors/account/account.go new file mode 100644 index 00000000..b1e69a8e --- /dev/null +++ b/actors/account/account.go @@ -0,0 +1,32 @@ +package account + +import ( + "bytes" + "encoding/base64" + + "github.com/filecoin-project/go-address" + "github.com/zondax/fil-parser/parser" +) + +func PubkeyAddress(raw, rawReturn []byte) (map[string]interface{}, error) { + metadata := make(map[string]interface{}) + metadata[parser.ParamsKey] = base64.StdEncoding.EncodeToString(raw) + reader := bytes.NewReader(rawReturn) + var r address.Address + err := r.UnmarshalCBOR(reader) + if err != nil { + return metadata, err + } + metadata[parser.ReturnKey] = r.String() + return metadata, nil +} + +func AuthenticateMessage(height int64, raw, rawReturn []byte) (map[string]interface{}, error) { + switch height { + case 11: + return authenticateMessagev11(raw, rawReturn) + case 14: + return authenticateMessagev14(raw, rawReturn) + } + return nil, nil +} diff --git a/actors/account/authenticate.go b/actors/account/authenticate.go new file mode 100644 index 00000000..ac9f5d5b --- /dev/null +++ b/actors/account/authenticate.go @@ -0,0 +1,43 @@ +package account + +import ( + "bytes" + + accountv11 "github.com/filecoin-project/go-state-types/builtin/v11/account" + accountv14 "github.com/filecoin-project/go-state-types/builtin/v14/account" + typegen "github.com/whyrusleeping/cbor-gen" + "github.com/zondax/fil-parser/parser" +) + +type authenticateMessageParams interface { + UnmarshalCBOR(r *bytes.Reader) error +} + +func authenticateMessage(raw, rawReturn []byte, params authenticateMessageParams) (map[string]interface{}, error) { + metadata := make(map[string]interface{}) + reader := bytes.NewReader(raw) + err := params.UnmarshalCBOR(reader) + if err != nil { + return metadata, err + } + metadata[parser.ParamsKey] = params + reader = bytes.NewReader(rawReturn) + var expiredReturn typegen.CborBool + err = expiredReturn.UnmarshalCBOR(reader) + if err != nil { + return metadata, err + } + metadata[parser.ReturnKey] = expiredReturn + return metadata, nil +} + +// Version-specific wrappers +func authenticateMessagev11(raw, rawReturn []byte) (map[string]interface{}, error) { + params := &accountv11.AuthenticateMessageParams{} + return authenticateMessage(raw, rawReturn, params) +} + +func authenticateMessagev14(raw, rawReturn []byte) (map[string]interface{}, error) { + params := &accountv14.AuthenticateMessageParams{} + return authenticateMessage(raw, rawReturn, params) +} diff --git a/actors/actor.go b/actors/actor.go index 1aa34a1f..7e9eec71 100644 --- a/actors/actor.go +++ b/actors/actor.go @@ -42,7 +42,7 @@ func (p *ActorParser) GetMetadata(txType string, msg *parser.LotusMessage, mainM case manifest.CronKey: metadata, err = p.ParseCron(txType, msg, msgRct) case manifest.AccountKey: - metadata, err = p.ParseAccount(txType, msg, msgRct) + metadata, err = p.ParseAccount(height, txType, msg, msgRct) case manifest.PowerKey: metadata, addressInfo, err = p.ParseStoragepower(txType, msg, msgRct) case manifest.MinerKey: diff --git a/actors/cron/constructor.go b/actors/cron/constructor.go new file mode 100644 index 00000000..df7b84d4 --- /dev/null +++ b/actors/cron/constructor.go @@ -0,0 +1,39 @@ +package cron + +import ( + "bytes" + "io" + + cronv8 "github.com/filecoin-project/specs-actors/v8/actors/builtin/cron" + + "github.com/zondax/fil-parser/parser" +) + +type cronConstructorParams interface { + UnmarshalCBOR(r io.Reader) error +} + +func cronConstructorv8(raw []byte) (map[string]interface{}, error) { + params := &cronv8.ConstructorParams{} + return cronConstructor(raw, params) +} + +func cronConstructor(raw []byte, params cronConstructorParams) (map[string]interface{}, error) { + metadata := make(map[string]interface{}) + reader := bytes.NewReader(raw) + err := params.UnmarshalCBOR(reader) + if err != nil { + return metadata, err + } + metadata[parser.ParamsKey] = params + return metadata, nil +} + +// func cronConstructorv11(raw []byte) (map[string]interface{}, error) { +// params := &cronv11.ConstructorParams{} +// return cronConstructor(raw, params) +// } +// func cronConstructorv14(raw []byte) (map[string]interface{}, error) { +// params := &cronv14.ConstructorParams{} +// return cronConstructor(raw, params) +// } diff --git a/actors/cron/cron.go b/actors/cron/cron.go new file mode 100644 index 00000000..6085388c --- /dev/null +++ b/actors/cron/cron.go @@ -0,0 +1,10 @@ +package cron + +func CronConstructor(height uint64, raw []byte) (map[string]interface{}, error) { + switch height { + case 8: + return cronConstructorv8(raw) + + } + return nil, nil +} diff --git a/actors/datacap/allowance.go b/actors/datacap/allowance.go new file mode 100644 index 00000000..3a0f7b1d --- /dev/null +++ b/actors/datacap/allowance.go @@ -0,0 +1,124 @@ +package datacap + +import ( + "bytes" + + "github.com/filecoin-project/go-state-types/abi" + "github.com/filecoin-project/go-state-types/builtin/v10/datacap" + "github.com/zondax/fil-parser/parser" +) + +type ( + increaseAllowanceParams = unmarshalCBOR + decreaseAllowanceParams = unmarshalCBOR + revokeAllowanceParams = unmarshalCBOR + allowanceParams = unmarshalCBOR +) + +func increaseAllowanceExportedv11(raw, rawReturn []byte) (map[string]interface{}, error) { + return increaseAllowanceExported(raw, rawReturn, &datacap.IncreaseAllowanceParams{}) +} + +func increaseAllowanceExportedv14(raw, rawReturn []byte) (map[string]interface{}, error) { + return increaseAllowanceExported(raw, rawReturn, &datacap.IncreaseAllowanceParams{}) +} + +func decreaseAllowanceExportedv11(raw, rawReturn []byte) (map[string]interface{}, error) { + return decreaseAllowanceExported(raw, rawReturn, &datacap.DecreaseAllowanceParams{}) +} + +func decreaseAllowanceExportedv14(raw, rawReturn []byte) (map[string]interface{}, error) { + return decreaseAllowanceExported(raw, rawReturn, &datacap.DecreaseAllowanceParams{}) +} + +func revokeAllowanceExportedv11(raw, rawReturn []byte) (map[string]interface{}, error) { + return revokeAllowanceExported(raw, rawReturn, &datacap.RevokeAllowanceParams{}) +} + +func revokeAllowanceExportedv14(raw, rawReturn []byte) (map[string]interface{}, error) { + return revokeAllowanceExported(raw, rawReturn, &datacap.RevokeAllowanceParams{}) +} + +func allowanceExportedv11(raw, rawReturn []byte) (map[string]interface{}, error) { + return allowanceExported(raw, rawReturn, &datacap.GetAllowanceParams{}) +} + +func allowanceExportedv14(raw, rawReturn []byte) (map[string]interface{}, error) { + return allowanceExported(raw, rawReturn, &datacap.GetAllowanceParams{}) +} + +func increaseAllowanceExported(raw, rawReturn []byte, params increaseAllowanceParams) (map[string]interface{}, error) { + metadata := make(map[string]interface{}) + reader := bytes.NewReader(raw) + err := params.UnmarshalCBOR(reader) + if err != nil { + return metadata, err + } + metadata[parser.ParamsKey] = params + + reader = bytes.NewReader(rawReturn) + var r abi.TokenAmount + err = r.UnmarshalCBOR(reader) + if err != nil { + return metadata, err + } + metadata[parser.ReturnKey] = r // TODO: .uint64()?? + return metadata, nil +} + +func decreaseAllowanceExported(raw, rawReturn []byte, params decreaseAllowanceParams) (map[string]interface{}, error) { + metadata := make(map[string]interface{}) + reader := bytes.NewReader(raw) + err := params.UnmarshalCBOR(reader) + if err != nil { + return metadata, err + } + metadata[parser.ParamsKey] = params + + reader = bytes.NewReader(rawReturn) + var r abi.TokenAmount + err = r.UnmarshalCBOR(reader) + if err != nil { + return metadata, err + } + metadata[parser.ReturnKey] = r // TODO: .uint64()?? + return metadata, nil +} + +func revokeAllowanceExported(raw, rawReturn []byte, params revokeAllowanceParams) (map[string]interface{}, error) { + metadata := make(map[string]interface{}) + reader := bytes.NewReader(raw) + err := params.UnmarshalCBOR(reader) + if err != nil { + return metadata, err + } + metadata[parser.ParamsKey] = params + + reader = bytes.NewReader(rawReturn) + var r abi.TokenAmount + err = r.UnmarshalCBOR(reader) + if err != nil { + return metadata, err + } + metadata[parser.ReturnKey] = r // TODO: .uint64()?? + return metadata, nil +} + +func allowanceExported(raw, rawReturn []byte, params allowanceParams) (map[string]interface{}, error) { + metadata := make(map[string]interface{}) + reader := bytes.NewReader(raw) + err := params.UnmarshalCBOR(reader) + if err != nil { + return metadata, err + } + metadata[parser.ParamsKey] = params + + reader = bytes.NewReader(rawReturn) + var r abi.TokenAmount + err = r.UnmarshalCBOR(reader) + if err != nil { + return metadata, err + } + metadata[parser.ReturnKey] = r // TODO: .uint64()?? + return metadata, nil +} diff --git a/actors/datacap/burn.go b/actors/datacap/burn.go new file mode 100644 index 00000000..83494ba8 --- /dev/null +++ b/actors/datacap/burn.go @@ -0,0 +1,94 @@ +package datacap + +import ( + "bytes" + + "github.com/filecoin-project/go-state-types/builtin/v10/datacap" + "github.com/zondax/fil-parser/parser" +) + +type ( + burnParams = unmarshalCBOR + burnReturn = unmarshalCBOR + destroyParams = unmarshalCBOR + burnFromParams = unmarshalCBOR + burnFromReturn = unmarshalCBOR +) + +func burnExported(raw, rawReturn []byte, params burnParams, r burnReturn) (map[string]interface{}, error) { + metadata := make(map[string]interface{}) + reader := bytes.NewReader(raw) + err := params.UnmarshalCBOR(reader) + if err != nil { + return metadata, err + } + metadata[parser.ParamsKey] = params + + reader = bytes.NewReader(rawReturn) + err = r.UnmarshalCBOR(reader) + if err != nil { + return metadata, err + } + metadata[parser.ReturnKey] = r + return metadata, nil +} + +func burnExportedv11(raw, rawReturn []byte) (map[string]interface{}, error) { + return burnExported(raw, rawReturn, &datacap.BurnParams{}, &datacap.BurnReturn{}) +} + +func burnExportedv14(raw, rawReturn []byte) (map[string]interface{}, error) { + return burnExported(raw, rawReturn, &datacap.BurnParams{}, &datacap.BurnReturn{}) +} + +func destroyExported(raw, rawReturn []byte, params destroyParams, r burnReturn) (map[string]interface{}, error) { + metadata := make(map[string]interface{}) + reader := bytes.NewReader(raw) + err := params.UnmarshalCBOR(reader) + if err != nil { + return metadata, err + } + metadata[parser.ParamsKey] = params + + reader = bytes.NewReader(rawReturn) + err = r.UnmarshalCBOR(reader) + if err != nil { + return metadata, err + } + metadata[parser.ReturnKey] = r + return metadata, nil +} + +func destroyExportedv11(raw, rawReturn []byte) (map[string]interface{}, error) { + return destroyExported(raw, rawReturn, &datacap.DestroyParams{}, &datacap.BurnReturn{}) +} + +func destroyExportedv14(raw, rawReturn []byte) (map[string]interface{}, error) { + return destroyExported(raw, rawReturn, &datacap.DestroyParams{}, &datacap.BurnReturn{}) +} + +func burnFromExported(raw, rawReturn []byte, params burnFromParams, r burnFromReturn) (map[string]interface{}, error) { + metadata := make(map[string]interface{}) + reader := bytes.NewReader(raw) + err := params.UnmarshalCBOR(reader) + if err != nil { + return metadata, err + } + metadata[parser.ParamsKey] = params + + reader = bytes.NewReader(rawReturn) + err = r.UnmarshalCBOR(reader) + if err != nil { + return metadata, err + } + metadata[parser.ReturnKey] = r + return metadata, nil +} + +func burnFromExportedv11(raw, rawReturn []byte) (map[string]interface{}, error) { + return burnFromExported(raw, rawReturn, &datacap.BurnFromParams{}, &datacap.BurnFromReturn{}) +} + +func burnFromExportedv14(raw, rawReturn []byte) (map[string]interface{}, error) { + return burnFromExported(raw, rawReturn, &datacap.BurnFromParams{}, &datacap.BurnFromReturn{}) +} diff --git a/actors/datacap/datacap.go b/actors/datacap/datacap.go new file mode 100644 index 00000000..19375922 --- /dev/null +++ b/actors/datacap/datacap.go @@ -0,0 +1,49 @@ +package datacap + +import ( + "bytes" + "io" + + "github.com/filecoin-project/go-state-types/abi" + "github.com/zondax/fil-parser/parser" +) + +type unmarshalCBOR interface { + UnmarshalCBOR(io.Reader) error +} + +func NameExported(rawReturn []byte) (map[string]interface{}, error) { + metadata := make(map[string]interface{}) + reader := bytes.NewReader(rawReturn) + var r abi.CborString + err := r.UnmarshalCBOR(reader) + if err != nil { + return metadata, err + } + metadata[parser.ReturnKey] = r + return metadata, nil +} + +func SymbolExported(rawReturn []byte) (map[string]interface{}, error) { + metadata := make(map[string]interface{}) + reader := bytes.NewReader(rawReturn) + var r abi.CborString + err := r.UnmarshalCBOR(reader) + if err != nil { + return metadata, err + } + metadata[parser.ReturnKey] = r + return metadata, nil +} + +func TotalSupplyExported(rawReturn []byte) (map[string]interface{}, error) { + metadata := make(map[string]interface{}) + reader := bytes.NewReader(rawReturn) + var r abi.TokenAmount + err := r.UnmarshalCBOR(reader) + if err != nil { + return metadata, err + } + metadata[parser.ReturnKey] = r // TODO: .uint64()?? + return metadata, nil +} diff --git a/actors/datacap/granularity.go b/actors/datacap/granularity.go new file mode 100644 index 00000000..225e1553 --- /dev/null +++ b/actors/datacap/granularity.go @@ -0,0 +1,29 @@ +package datacap + +import ( + "bytes" + + "github.com/filecoin-project/go-state-types/builtin/v10/datacap" + "github.com/zondax/fil-parser/parser" +) + +type granularityReturn = unmarshalCBOR + +func granularityExported(rawReturn []byte, r granularityReturn) (map[string]interface{}, error) { + metadata := make(map[string]interface{}) + reader := bytes.NewReader(rawReturn) + err := r.UnmarshalCBOR(reader) + if err != nil { + return metadata, err + } + metadata[parser.ReturnKey] = r + return metadata, nil +} + +func granularityExportedv11(rawReturn []byte) (map[string]interface{}, error) { + return granularityExported(rawReturn, datacap.GranularityReturn{}) +} + +func granularityExportedv14(rawReturn []byte) (map[string]interface{}, error) { + return granularityExported(rawReturn, datacap.GranularityReturn{}) +} diff --git a/actors/datacap/mint.go b/actors/datacap/mint.go new file mode 100644 index 00000000..6b3a5ead --- /dev/null +++ b/actors/datacap/mint.go @@ -0,0 +1,39 @@ +package datacap + +import ( + "bytes" + + "github.com/filecoin-project/go-state-types/builtin/v10/datacap" + "github.com/zondax/fil-parser/parser" +) + +type ( + mintParams = unmarshalCBOR + mintReturn = unmarshalCBOR +) + +func mintExported(raw, rawReturn []byte, params mintParams, r mintReturn) (map[string]interface{}, error) { + metadata := make(map[string]interface{}) + reader := bytes.NewReader(raw) + err := params.UnmarshalCBOR(reader) + if err != nil { + return metadata, err + } + metadata[parser.ParamsKey] = params + + reader = bytes.NewReader(rawReturn) + err = r.UnmarshalCBOR(reader) + if err != nil { + return metadata, err + } + metadata[parser.ReturnKey] = r + return metadata, nil +} + +func mintExportedv11(raw, rawReturn []byte) (map[string]interface{}, error) { + return mintExported(raw, rawReturn, &datacap.MintParams{}, &datacap.MintReturn{}) +} + +func mintExportedv14(raw, rawReturn []byte) (map[string]interface{}, error) { + return mintExported(raw, rawReturn, &datacap.MintParams{}, &datacap.MintReturn{}) +} diff --git a/actors/datacap/transfer.go b/actors/datacap/transfer.go new file mode 100644 index 00000000..eed7d64e --- /dev/null +++ b/actors/datacap/transfer.go @@ -0,0 +1,67 @@ +package datacap + +import ( + "bytes" + + "github.com/filecoin-project/go-state-types/builtin/v10/datacap" + "github.com/zondax/fil-parser/parser" +) + +type ( + transferParams = unmarshalCBOR + transferReturn = unmarshalCBOR + transferFromParams = unmarshalCBOR + transferFromReturn = unmarshalCBOR +) + +func transferExported(raw, rawReturn []byte, params transferParams, r transferReturn) (map[string]interface{}, error) { + metadata := make(map[string]interface{}) + reader := bytes.NewReader(raw) + err := params.UnmarshalCBOR(reader) + if err != nil { + return metadata, err + } + metadata[parser.ParamsKey] = params + + reader = bytes.NewReader(rawReturn) + err = r.UnmarshalCBOR(reader) + if err != nil { + return metadata, err + } + metadata[parser.ReturnKey] = r + return metadata, nil +} + +func transferExportedv11(raw, rawReturn []byte) (map[string]interface{}, error) { + return transferExported(raw, rawReturn, &datacap.TransferParams{}, &datacap.TransferReturn{}) +} + +func transferExportedv14(raw, rawReturn []byte) (map[string]interface{}, error) { + return transferExported(raw, rawReturn, &datacap.TransferParams{}, &datacap.TransferReturn{}) +} + +func transferFromExported(raw, rawReturn []byte, params transferFromParams, r transferFromReturn) (map[string]interface{}, error) { + metadata := make(map[string]interface{}) + reader := bytes.NewReader(raw) + err := params.UnmarshalCBOR(reader) + if err != nil { + return metadata, err + } + metadata[parser.ParamsKey] = params + + reader = bytes.NewReader(rawReturn) + err = r.UnmarshalCBOR(reader) + if err != nil { + return metadata, err + } + metadata[parser.ReturnKey] = r + return metadata, nil +} + +func transferFromExportedv11(raw, rawReturn []byte) (map[string]interface{}, error) { + return transferFromExported(raw, rawReturn, &datacap.TransferFromParams{}, &datacap.TransferFromReturn{}) +} + +func transferFromExportedv14(raw, rawReturn []byte) (map[string]interface{}, error) { + return transferFromExported(raw, rawReturn, &datacap.TransferFromParams{}, &datacap.TransferFromReturn{}) +} From c58c6d9c17ffb922aa166c1a25f6ef66a8cdeb94 Mon Sep 17 00:00:00 2001 From: Eric Mokaya Date: Tue, 21 Jan 2025 15:11:22 +0300 Subject: [PATCH 02/16] feat: refine abstractions based on emerging patterns --- actors/account/account.go | 9 ++ actors/account/authenticate.go | 44 +++++- actors/cron/constructor.go | 44 ++++-- actors/cron/cron.go | 14 +- actors/datacap/allowance.go | 260 +++++++++++++++++++++++--------- actors/datacap/burn.go | 170 ++++++++++++++++----- actors/datacap/datacap.go | 28 +--- actors/datacap/granularity.go | 58 +++++++- actors/datacap/mint.go | 55 ++++++- actors/datacap/transfer.go | 78 ++++++---- actors/eam/return.go | 261 +++++++++++++++++++++++++++++++++ actors/evm/evm.go | 211 ++++++++++++++++++++++++++ actors/init/init.go | 237 ++++++++++++++++++++++++++++++ actors/market/market.go | 1 + 14 files changed, 1286 insertions(+), 184 deletions(-) create mode 100644 actors/eam/return.go create mode 100644 actors/evm/evm.go create mode 100644 actors/init/init.go create mode 100644 actors/market/market.go diff --git a/actors/account/account.go b/actors/account/account.go index b1e69a8e..6f7cf203 100644 --- a/actors/account/account.go +++ b/actors/account/account.go @@ -3,6 +3,7 @@ package account import ( "bytes" "encoding/base64" + "fmt" "github.com/filecoin-project/go-address" "github.com/zondax/fil-parser/parser" @@ -23,10 +24,18 @@ func PubkeyAddress(raw, rawReturn []byte) (map[string]interface{}, error) { func AuthenticateMessage(height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch height { + case 8: + return nil, fmt.Errorf("not supported") + case 9: + return authenticateMessagev9(raw, rawReturn) + case 10: + return authenticateMessagev10(raw, rawReturn) case 11: return authenticateMessagev11(raw, rawReturn) case 14: return authenticateMessagev14(raw, rawReturn) + case 15: + return authenticateMessagev15(raw, rawReturn) } return nil, nil } diff --git a/actors/account/authenticate.go b/actors/account/authenticate.go index ac9f5d5b..8bc240dc 100644 --- a/actors/account/authenticate.go +++ b/actors/account/authenticate.go @@ -2,18 +2,25 @@ package account import ( "bytes" + "io" + accountv10 "github.com/filecoin-project/go-state-types/builtin/v10/account" accountv11 "github.com/filecoin-project/go-state-types/builtin/v11/account" + accountv9 "github.com/filecoin-project/go-state-types/builtin/v11/account" + accountv12 "github.com/filecoin-project/go-state-types/builtin/v12/account" + accountv13 "github.com/filecoin-project/go-state-types/builtin/v13/account" accountv14 "github.com/filecoin-project/go-state-types/builtin/v14/account" + accountv15 "github.com/filecoin-project/go-state-types/builtin/v15/account" + typegen "github.com/whyrusleeping/cbor-gen" "github.com/zondax/fil-parser/parser" ) type authenticateMessageParams interface { - UnmarshalCBOR(r *bytes.Reader) error + UnmarshalCBOR(r io.Reader) error } -func authenticateMessage(raw, rawReturn []byte, params authenticateMessageParams) (map[string]interface{}, error) { +func authenticateMessageGeneric[P authenticateMessageParams](raw, rawReturn []byte, params P) (map[string]interface{}, error) { metadata := make(map[string]interface{}) reader := bytes.NewReader(raw) err := params.UnmarshalCBOR(reader) @@ -32,12 +39,35 @@ func authenticateMessage(raw, rawReturn []byte, params authenticateMessageParams } // Version-specific wrappers -func authenticateMessagev11(raw, rawReturn []byte) (map[string]interface{}, error) { - params := &accountv11.AuthenticateMessageParams{} - return authenticateMessage(raw, rawReturn, params) + +func authenticateMessagev15(raw, rawReturn []byte) (map[string]interface{}, error) { + return authenticateMessageGeneric[*accountv15.AuthenticateMessageParams](raw, rawReturn, &accountv15.AuthenticateMessageParams{}) } func authenticateMessagev14(raw, rawReturn []byte) (map[string]interface{}, error) { - params := &accountv14.AuthenticateMessageParams{} - return authenticateMessage(raw, rawReturn, params) + return authenticateMessageGeneric[*accountv14.AuthenticateMessageParams](raw, rawReturn, &accountv14.AuthenticateMessageParams{}) +} + +func authenticateMessagev13(raw, rawReturn []byte) (map[string]interface{}, error) { + return authenticateMessageGeneric[*accountv13.AuthenticateMessageParams](raw, rawReturn, &accountv13.AuthenticateMessageParams{}) +} + +func authenticateMessagev12(raw, rawReturn []byte) (map[string]interface{}, error) { + return authenticateMessageGeneric[*accountv12.AuthenticateMessageParams](raw, rawReturn, &accountv12.AuthenticateMessageParams{}) } + +func authenticateMessagev11(raw, rawReturn []byte) (map[string]interface{}, error) { + return authenticateMessageGeneric[*accountv11.AuthenticateMessageParams](raw, rawReturn, &accountv11.AuthenticateMessageParams{}) +} + +func authenticateMessagev10(raw, rawReturn []byte) (map[string]interface{}, error) { + return authenticateMessageGeneric[*accountv10.AuthenticateMessageParams](raw, rawReturn, &accountv10.AuthenticateMessageParams{}) +} + +func authenticateMessagev9(raw, rawReturn []byte) (map[string]interface{}, error) { + return authenticateMessageGeneric[*accountv9.AuthenticateMessageParams](raw, rawReturn, &accountv9.AuthenticateMessageParams{}) +} + +// func authenticateMessagev8(raw, rawReturn []byte) (map[string]interface{}, error) { +// return authenticateMessageGeneric[*accountv8.AuthenticateMessageParams](raw, rawReturn, &accountv8.AuthenticateMessageParams{}) +// } diff --git a/actors/cron/constructor.go b/actors/cron/constructor.go index df7b84d4..6cc1021c 100644 --- a/actors/cron/constructor.go +++ b/actors/cron/constructor.go @@ -4,6 +4,12 @@ import ( "bytes" "io" + cronv2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/cron" + cronv3 "github.com/filecoin-project/specs-actors/v3/actors/builtin/cron" + cronv4 "github.com/filecoin-project/specs-actors/v4/actors/builtin/cron" + cronv5 "github.com/filecoin-project/specs-actors/v5/actors/builtin/cron" + cronv6 "github.com/filecoin-project/specs-actors/v6/actors/builtin/cron" + cronv7 "github.com/filecoin-project/specs-actors/v7/actors/builtin/cron" cronv8 "github.com/filecoin-project/specs-actors/v8/actors/builtin/cron" "github.com/zondax/fil-parser/parser" @@ -14,11 +20,34 @@ type cronConstructorParams interface { } func cronConstructorv8(raw []byte) (map[string]interface{}, error) { - params := &cronv8.ConstructorParams{} - return cronConstructor(raw, params) + return cronConstructorGeneric[*cronv8.ConstructorParams](raw, &cronv8.ConstructorParams{}) } -func cronConstructor(raw []byte, params cronConstructorParams) (map[string]interface{}, error) { +func cronConstructorv7(raw []byte) (map[string]interface{}, error) { + return cronConstructorGeneric[*cronv7.ConstructorParams](raw, &cronv7.ConstructorParams{}) +} + +func cronConstructorv6(raw []byte) (map[string]interface{}, error) { + return cronConstructorGeneric[*cronv6.ConstructorParams](raw, &cronv6.ConstructorParams{}) +} + +func cronConstructorv5(raw []byte) (map[string]interface{}, error) { + return cronConstructorGeneric[*cronv5.ConstructorParams](raw, &cronv5.ConstructorParams{}) +} + +func cronConstructorv4(raw []byte) (map[string]interface{}, error) { + return cronConstructorGeneric[*cronv4.ConstructorParams](raw, &cronv4.ConstructorParams{}) +} + +func cronConstructorv3(raw []byte) (map[string]interface{}, error) { + return cronConstructorGeneric[*cronv3.ConstructorParams](raw, &cronv3.ConstructorParams{}) +} + +func cronConstructorv2(raw []byte) (map[string]interface{}, error) { + return cronConstructorGeneric[*cronv2.ConstructorParams](raw, &cronv2.ConstructorParams{}) +} + +func cronConstructorGeneric[P cronConstructorParams](raw []byte, params P) (map[string]interface{}, error) { metadata := make(map[string]interface{}) reader := bytes.NewReader(raw) err := params.UnmarshalCBOR(reader) @@ -28,12 +57,3 @@ func cronConstructor(raw []byte, params cronConstructorParams) (map[string]inter metadata[parser.ParamsKey] = params return metadata, nil } - -// func cronConstructorv11(raw []byte) (map[string]interface{}, error) { -// params := &cronv11.ConstructorParams{} -// return cronConstructor(raw, params) -// } -// func cronConstructorv14(raw []byte) (map[string]interface{}, error) { -// params := &cronv14.ConstructorParams{} -// return cronConstructor(raw, params) -// } diff --git a/actors/cron/cron.go b/actors/cron/cron.go index 6085388c..631fd738 100644 --- a/actors/cron/cron.go +++ b/actors/cron/cron.go @@ -1,10 +1,22 @@ package cron +// TODO: update to correct height ranges func CronConstructor(height uint64, raw []byte) (map[string]interface{}, error) { switch height { case 8: return cronConstructorv8(raw) - + case 7: + return cronConstructorv7(raw) + case 6: + return cronConstructorv6(raw) + case 5: + return cronConstructorv5(raw) + case 4: + return cronConstructorv4(raw) + case 3: + return cronConstructorv3(raw) + case 2: + return cronConstructorv2(raw) } return nil, nil } diff --git a/actors/datacap/allowance.go b/actors/datacap/allowance.go index 3a0f7b1d..82a81ab7 100644 --- a/actors/datacap/allowance.go +++ b/actors/datacap/allowance.go @@ -2,9 +2,16 @@ package datacap import ( "bytes" + "fmt" "github.com/filecoin-project/go-state-types/abi" - "github.com/filecoin-project/go-state-types/builtin/v10/datacap" + datacapv10 "github.com/filecoin-project/go-state-types/builtin/v10/datacap" + datacapv11 "github.com/filecoin-project/go-state-types/builtin/v11/datacap" + datacapv12 "github.com/filecoin-project/go-state-types/builtin/v12/datacap" + datacapv13 "github.com/filecoin-project/go-state-types/builtin/v13/datacap" + datacapv14 "github.com/filecoin-project/go-state-types/builtin/v14/datacap" + datacapv15 "github.com/filecoin-project/go-state-types/builtin/v15/datacap" + datacapv9 "github.com/filecoin-project/go-state-types/builtin/v9/datacap" "github.com/zondax/fil-parser/parser" ) @@ -15,39 +22,83 @@ type ( allowanceParams = unmarshalCBOR ) -func increaseAllowanceExportedv11(raw, rawReturn []byte) (map[string]interface{}, error) { - return increaseAllowanceExported(raw, rawReturn, &datacap.IncreaseAllowanceParams{}) -} - -func increaseAllowanceExportedv14(raw, rawReturn []byte) (map[string]interface{}, error) { - return increaseAllowanceExported(raw, rawReturn, &datacap.IncreaseAllowanceParams{}) +type allowanceParamsInterface interface { + unmarshalCBOR } -func decreaseAllowanceExportedv11(raw, rawReturn []byte) (map[string]interface{}, error) { - return decreaseAllowanceExported(raw, rawReturn, &datacap.DecreaseAllowanceParams{}) -} - -func decreaseAllowanceExportedv14(raw, rawReturn []byte) (map[string]interface{}, error) { - return decreaseAllowanceExported(raw, rawReturn, &datacap.DecreaseAllowanceParams{}) -} - -func revokeAllowanceExportedv11(raw, rawReturn []byte) (map[string]interface{}, error) { - return revokeAllowanceExported(raw, rawReturn, &datacap.RevokeAllowanceParams{}) +func IncreaseAllowance(height uint64, raw, rawReturn []byte) (map[string]interface{}, error) { + switch height { + case 8: + return nil, fmt.Errorf("not supported") + case 9: + return increaseAllowanceExportedv9(raw, rawReturn) + case 10: + return increaseAllowanceExportedv10(raw, rawReturn) + case 11: + return increaseAllowanceExportedv11(raw, rawReturn) + case 14: + return increaseAllowanceExportedv14(raw, rawReturn) + case 15: + return increaseAllowanceExportedv15(raw, rawReturn) + } + return nil, fmt.Errorf("not supported") } -func revokeAllowanceExportedv14(raw, rawReturn []byte) (map[string]interface{}, error) { - return revokeAllowanceExported(raw, rawReturn, &datacap.RevokeAllowanceParams{}) +func DecreaseAllowance(height uint64, raw, rawReturn []byte) (map[string]interface{}, error) { + switch height { + case 8: + return nil, fmt.Errorf("not supported") + case 9: + return decreaseAllowanceExportedv9(raw, rawReturn) + case 10: + return decreaseAllowanceExportedv10(raw, rawReturn) + case 11: + return decreaseAllowanceExportedv11(raw, rawReturn) + case 14: + return decreaseAllowanceExportedv14(raw, rawReturn) + case 15: + return decreaseAllowanceExportedv15(raw, rawReturn) + } + return nil, fmt.Errorf("not supported") } -func allowanceExportedv11(raw, rawReturn []byte) (map[string]interface{}, error) { - return allowanceExported(raw, rawReturn, &datacap.GetAllowanceParams{}) +func RevokeAllowance(height uint64, raw, rawReturn []byte) (map[string]interface{}, error) { + switch height { + case 8: + return nil, fmt.Errorf("not supported") + case 9: + return revokeAllowanceExportedv9(raw, rawReturn) + case 10: + return revokeAllowanceExportedv10(raw, rawReturn) + case 11: + return revokeAllowanceExportedv11(raw, rawReturn) + case 14: + return revokeAllowanceExportedv14(raw, rawReturn) + case 15: + return revokeAllowanceExportedv15(raw, rawReturn) + } + return nil, fmt.Errorf("not supported") } -func allowanceExportedv14(raw, rawReturn []byte) (map[string]interface{}, error) { - return allowanceExported(raw, rawReturn, &datacap.GetAllowanceParams{}) +func GetAllowance(height uint64, raw, rawReturn []byte) (map[string]interface{}, error) { + switch height { + case 8: + return nil, fmt.Errorf("not supported") + case 9: + return allowanceExportedv9(raw, rawReturn) + case 10: + return allowanceExportedv10(raw, rawReturn) + case 11: + return allowanceExportedv11(raw, rawReturn) + case 14: + return allowanceExportedv14(raw, rawReturn) + case 15: + return allowanceExportedv15(raw, rawReturn) + } + return nil, fmt.Errorf("not supported") } -func increaseAllowanceExported(raw, rawReturn []byte, params increaseAllowanceParams) (map[string]interface{}, error) { +func allowanceGeneric[T allowanceParamsInterface](raw []byte, rawReturn []byte, params T) (map[string]interface{}, error) { metadata := make(map[string]interface{}) reader := bytes.NewReader(raw) err := params.UnmarshalCBOR(reader) @@ -62,63 +113,126 @@ func increaseAllowanceExported(raw, rawReturn []byte, params increaseAllowancePa if err != nil { return metadata, err } - metadata[parser.ReturnKey] = r // TODO: .uint64()?? + metadata[parser.ReturnKey] = r return metadata, nil } -func decreaseAllowanceExported(raw, rawReturn []byte, params decreaseAllowanceParams) (map[string]interface{}, error) { - metadata := make(map[string]interface{}) - reader := bytes.NewReader(raw) - err := params.UnmarshalCBOR(reader) - if err != nil { - return metadata, err - } - metadata[parser.ParamsKey] = params +// Increase Allowance - reader = bytes.NewReader(rawReturn) - var r abi.TokenAmount - err = r.UnmarshalCBOR(reader) - if err != nil { - return metadata, err - } - metadata[parser.ReturnKey] = r // TODO: .uint64()?? - return metadata, nil +func increaseAllowanceExportedv9(raw, rawReturn []byte) (map[string]interface{}, error) { + return allowanceGeneric(raw, rawReturn, &datacapv9.IncreaseAllowanceParams{}) } -func revokeAllowanceExported(raw, rawReturn []byte, params revokeAllowanceParams) (map[string]interface{}, error) { - metadata := make(map[string]interface{}) - reader := bytes.NewReader(raw) - err := params.UnmarshalCBOR(reader) - if err != nil { - return metadata, err - } - metadata[parser.ParamsKey] = params +func increaseAllowanceExportedv10(raw, rawReturn []byte) (map[string]interface{}, error) { + return allowanceGeneric(raw, rawReturn, &datacapv10.IncreaseAllowanceParams{}) +} - reader = bytes.NewReader(rawReturn) - var r abi.TokenAmount - err = r.UnmarshalCBOR(reader) - if err != nil { - return metadata, err - } - metadata[parser.ReturnKey] = r // TODO: .uint64()?? - return metadata, nil +func increaseAllowanceExportedv11(raw, rawReturn []byte) (map[string]interface{}, error) { + return allowanceGeneric(raw, rawReturn, &datacapv11.IncreaseAllowanceParams{}) } -func allowanceExported(raw, rawReturn []byte, params allowanceParams) (map[string]interface{}, error) { - metadata := make(map[string]interface{}) - reader := bytes.NewReader(raw) - err := params.UnmarshalCBOR(reader) - if err != nil { - return metadata, err - } - metadata[parser.ParamsKey] = params +func increaseAllowanceExportedv12(raw, rawReturn []byte) (map[string]interface{}, error) { + return allowanceGeneric(raw, rawReturn, &datacapv12.IncreaseAllowanceParams{}) +} - reader = bytes.NewReader(rawReturn) - var r abi.TokenAmount - err = r.UnmarshalCBOR(reader) - if err != nil { - return metadata, err - } - metadata[parser.ReturnKey] = r // TODO: .uint64()?? - return metadata, nil +func increaseAllowanceExportedv13(raw, rawReturn []byte) (map[string]interface{}, error) { + return allowanceGeneric(raw, rawReturn, &datacapv13.IncreaseAllowanceParams{}) +} + +func increaseAllowanceExportedv14(raw, rawReturn []byte) (map[string]interface{}, error) { + return allowanceGeneric(raw, rawReturn, &datacapv14.IncreaseAllowanceParams{}) +} + +func increaseAllowanceExportedv15(raw, rawReturn []byte) (map[string]interface{}, error) { + return allowanceGeneric(raw, rawReturn, &datacapv15.IncreaseAllowanceParams{}) +} + +// Decrease Allowance + +func decreaseAllowanceExportedv9(raw, rawReturn []byte) (map[string]interface{}, error) { + return allowanceGeneric(raw, rawReturn, &datacapv9.DecreaseAllowanceParams{}) +} + +func decreaseAllowanceExportedv10(raw, rawReturn []byte) (map[string]interface{}, error) { + return allowanceGeneric(raw, rawReturn, &datacapv10.DecreaseAllowanceParams{}) +} + +func decreaseAllowanceExportedv11(raw, rawReturn []byte) (map[string]interface{}, error) { + return allowanceGeneric(raw, rawReturn, &datacapv11.DecreaseAllowanceParams{}) +} + +func decreaseAllowanceExportedv12(raw, rawReturn []byte) (map[string]interface{}, error) { + return allowanceGeneric(raw, rawReturn, &datacapv12.DecreaseAllowanceParams{}) +} + +func decreaseAllowanceExportedv13(raw, rawReturn []byte) (map[string]interface{}, error) { + return allowanceGeneric(raw, rawReturn, &datacapv13.DecreaseAllowanceParams{}) +} + +func decreaseAllowanceExportedv14(raw, rawReturn []byte) (map[string]interface{}, error) { + return allowanceGeneric(raw, rawReturn, &datacapv14.DecreaseAllowanceParams{}) +} + +func decreaseAllowanceExportedv15(raw, rawReturn []byte) (map[string]interface{}, error) { + return allowanceGeneric(raw, rawReturn, &datacapv15.DecreaseAllowanceParams{}) +} + +// Revoke Allowance + +func revokeAllowanceExportedv9(raw, rawReturn []byte) (map[string]interface{}, error) { + return allowanceGeneric(raw, rawReturn, &datacapv9.RevokeAllowanceParams{}) +} + +func revokeAllowanceExportedv10(raw, rawReturn []byte) (map[string]interface{}, error) { + return allowanceGeneric(raw, rawReturn, &datacapv10.RevokeAllowanceParams{}) +} + +func revokeAllowanceExportedv11(raw, rawReturn []byte) (map[string]interface{}, error) { + return allowanceGeneric(raw, rawReturn, &datacapv11.RevokeAllowanceParams{}) +} + +func revokeAllowanceExportedv12(raw, rawReturn []byte) (map[string]interface{}, error) { + return allowanceGeneric(raw, rawReturn, &datacapv12.RevokeAllowanceParams{}) +} + +func revokeAllowanceExportedv13(raw, rawReturn []byte) (map[string]interface{}, error) { + return allowanceGeneric(raw, rawReturn, &datacapv13.RevokeAllowanceParams{}) +} + +func revokeAllowanceExportedv14(raw, rawReturn []byte) (map[string]interface{}, error) { + return allowanceGeneric(raw, rawReturn, &datacapv14.RevokeAllowanceParams{}) +} + +func revokeAllowanceExportedv15(raw, rawReturn []byte) (map[string]interface{}, error) { + return allowanceGeneric(raw, rawReturn, &datacapv15.RevokeAllowanceParams{}) +} + +// Get Allowance + +func allowanceExportedv9(raw, rawReturn []byte) (map[string]interface{}, error) { + return allowanceGeneric(raw, rawReturn, &datacapv9.GetAllowanceParams{}) +} + +func allowanceExportedv10(raw, rawReturn []byte) (map[string]interface{}, error) { + return allowanceGeneric(raw, rawReturn, &datacapv10.GetAllowanceParams{}) +} + +func allowanceExportedv11(raw, rawReturn []byte) (map[string]interface{}, error) { + return allowanceGeneric(raw, rawReturn, &datacapv11.GetAllowanceParams{}) +} + +func allowanceExportedv12(raw, rawReturn []byte) (map[string]interface{}, error) { + return allowanceGeneric(raw, rawReturn, &datacapv12.GetAllowanceParams{}) +} + +func allowanceExportedv13(raw, rawReturn []byte) (map[string]interface{}, error) { + return allowanceGeneric(raw, rawReturn, &datacapv13.GetAllowanceParams{}) +} + +func allowanceExportedv14(raw, rawReturn []byte) (map[string]interface{}, error) { + return allowanceGeneric(raw, rawReturn, &datacapv14.GetAllowanceParams{}) +} + +func allowanceExportedv15(raw, rawReturn []byte) (map[string]interface{}, error) { + return allowanceGeneric(raw, rawReturn, &datacapv15.GetAllowanceParams{}) } diff --git a/actors/datacap/burn.go b/actors/datacap/burn.go index 83494ba8..fc6648e1 100644 --- a/actors/datacap/burn.go +++ b/actors/datacap/burn.go @@ -2,8 +2,16 @@ package datacap import ( "bytes" + "fmt" - "github.com/filecoin-project/go-state-types/builtin/v10/datacap" + datacapv10 "github.com/filecoin-project/go-state-types/builtin/v10/datacap" + datacapv11 "github.com/filecoin-project/go-state-types/builtin/v11/datacap" + datacapv12 "github.com/filecoin-project/go-state-types/builtin/v12/datacap" + datacapv13 "github.com/filecoin-project/go-state-types/builtin/v13/datacap" + datacapv14 "github.com/filecoin-project/go-state-types/builtin/v14/datacap" + datacapv15 "github.com/filecoin-project/go-state-types/builtin/v15/datacap" + "github.com/filecoin-project/go-state-types/builtin/v9/datacap" + datacapv9 "github.com/filecoin-project/go-state-types/builtin/v9/datacap" "github.com/zondax/fil-parser/parser" ) @@ -15,7 +23,63 @@ type ( burnFromReturn = unmarshalCBOR ) -func burnExported(raw, rawReturn []byte, params burnParams, r burnReturn) (map[string]interface{}, error) { +func BurnExported(height uint64, raw, rawReturn []byte) (map[string]interface{}, error) { + switch height { + case 9: + return burnExportedv9(raw, rawReturn) + case 10: + return burnExportedv10(raw, rawReturn) + case 11: + return burnExportedv11(raw, rawReturn) + case 14: + return burnExportedv14(raw, rawReturn) + case 15: + return burnExportedv15(raw, rawReturn) + } + return nil, fmt.Errorf("not supported") +} + +func BurnFromExported(height uint64, raw, rawReturn []byte) (map[string]interface{}, error) { + switch height { + case 9: + return burnFromExportedv9(raw, rawReturn) + case 10: + return burnFromExportedv10(raw, rawReturn) + case 11: + return burnFromExportedv11(raw, rawReturn) + case 12: + return burnFromExportedv12(raw, rawReturn) + case 13: + return burnFromExportedv13(raw, rawReturn) + case 14: + return burnFromExportedv14(raw, rawReturn) + case 15: + return burnFromExportedv15(raw, rawReturn) + } + return nil, fmt.Errorf("not supported") +} + +func DestroyExported(height uint64, raw, rawReturn []byte) (map[string]interface{}, error) { + switch height { + case 9: + return destroyExportedv9(raw, rawReturn) + case 10: + return destroyExportedv10(raw, rawReturn) + case 11: + return destroyExportedv11(raw, rawReturn) + case 12: + return destroyExportedv12(raw, rawReturn) + case 13: + return destroyExportedv13(raw, rawReturn) + case 14: + return destroyExportedv14(raw, rawReturn) + case 15: + return destroyExportedv15(raw, rawReturn) + } + return nil, fmt.Errorf("not supported") +} + +func burnGeneric[P unmarshalCBOR, R unmarshalCBOR](raw []byte, rawReturn []byte, params P, r R) (map[string]interface{}, error) { metadata := make(map[string]interface{}) reader := bytes.NewReader(raw) err := params.UnmarshalCBOR(reader) @@ -33,62 +97,92 @@ func burnExported(raw, rawReturn []byte, params burnParams, r burnReturn) (map[s return metadata, nil } +// Burn Exported + +func burnExportedv9(raw, rawReturn []byte) (map[string]interface{}, error) { + return burnGeneric(raw, rawReturn, &datacapv9.BurnParams{}, &datacapv9.BurnReturn{}) +} + +func burnExportedv10(raw, rawReturn []byte) (map[string]interface{}, error) { + return burnGeneric(raw, rawReturn, &datacapv10.BurnParams{}, &datacapv10.BurnReturn{}) +} + func burnExportedv11(raw, rawReturn []byte) (map[string]interface{}, error) { - return burnExported(raw, rawReturn, &datacap.BurnParams{}, &datacap.BurnReturn{}) + return burnGeneric(raw, rawReturn, &datacapv11.BurnParams{}, &datacapv11.BurnReturn{}) +} + +func burnExportedv12(raw, rawReturn []byte) (map[string]interface{}, error) { + return burnGeneric(raw, rawReturn, &datacapv12.BurnParams{}, &datacapv12.BurnReturn{}) +} + +func burnExportedv13(raw, rawReturn []byte) (map[string]interface{}, error) { + return burnGeneric(raw, rawReturn, &datacapv13.BurnParams{}, &datacapv13.BurnReturn{}) } func burnExportedv14(raw, rawReturn []byte) (map[string]interface{}, error) { - return burnExported(raw, rawReturn, &datacap.BurnParams{}, &datacap.BurnReturn{}) + return burnGeneric(raw, rawReturn, &datacapv14.BurnParams{}, &datacapv14.BurnReturn{}) } -func destroyExported(raw, rawReturn []byte, params destroyParams, r burnReturn) (map[string]interface{}, error) { - metadata := make(map[string]interface{}) - reader := bytes.NewReader(raw) - err := params.UnmarshalCBOR(reader) - if err != nil { - return metadata, err - } - metadata[parser.ParamsKey] = params +func burnExportedv15(raw, rawReturn []byte) (map[string]interface{}, error) { + return burnGeneric(raw, rawReturn, &datacapv15.BurnParams{}, &datacapv15.BurnReturn{}) +} - reader = bytes.NewReader(rawReturn) - err = r.UnmarshalCBOR(reader) - if err != nil { - return metadata, err - } - metadata[parser.ReturnKey] = r - return metadata, nil +// Destroy Exported + +func destroyExportedv9(raw, rawReturn []byte) (map[string]interface{}, error) { + return burnGeneric(raw, rawReturn, &datacapv9.DestroyParams{}, &datacapv9.BurnReturn{}) +} + +func destroyExportedv10(raw, rawReturn []byte) (map[string]interface{}, error) { + return burnGeneric(raw, rawReturn, &datacapv10.DestroyParams{}, &datacapv10.BurnReturn{}) } func destroyExportedv11(raw, rawReturn []byte) (map[string]interface{}, error) { - return destroyExported(raw, rawReturn, &datacap.DestroyParams{}, &datacap.BurnReturn{}) + return burnGeneric(raw, rawReturn, &datacap.DestroyParams{}, &datacap.BurnReturn{}) +} + +func destroyExportedv12(raw, rawReturn []byte) (map[string]interface{}, error) { + return burnGeneric(raw, rawReturn, &datacapv12.DestroyParams{}, &datacapv12.BurnReturn{}) +} + +func destroyExportedv13(raw, rawReturn []byte) (map[string]interface{}, error) { + return burnGeneric(raw, rawReturn, &datacapv13.DestroyParams{}, &datacapv13.BurnReturn{}) } func destroyExportedv14(raw, rawReturn []byte) (map[string]interface{}, error) { - return destroyExported(raw, rawReturn, &datacap.DestroyParams{}, &datacap.BurnReturn{}) + return burnGeneric(raw, rawReturn, &datacapv14.DestroyParams{}, &datacapv14.BurnReturn{}) } -func burnFromExported(raw, rawReturn []byte, params burnFromParams, r burnFromReturn) (map[string]interface{}, error) { - metadata := make(map[string]interface{}) - reader := bytes.NewReader(raw) - err := params.UnmarshalCBOR(reader) - if err != nil { - return metadata, err - } - metadata[parser.ParamsKey] = params +func destroyExportedv15(raw, rawReturn []byte) (map[string]interface{}, error) { + return burnGeneric(raw, rawReturn, &datacapv15.DestroyParams{}, &datacapv15.BurnReturn{}) +} - reader = bytes.NewReader(rawReturn) - err = r.UnmarshalCBOR(reader) - if err != nil { - return metadata, err - } - metadata[parser.ReturnKey] = r - return metadata, nil +// Burn From Exported + +func burnFromExportedv9(raw, rawReturn []byte) (map[string]interface{}, error) { + return burnGeneric(raw, rawReturn, &datacapv9.BurnFromParams{}, &datacapv9.BurnFromReturn{}) +} + +func burnFromExportedv10(raw, rawReturn []byte) (map[string]interface{}, error) { + return burnGeneric(raw, rawReturn, &datacapv10.BurnFromParams{}, &datacapv10.BurnFromReturn{}) } func burnFromExportedv11(raw, rawReturn []byte) (map[string]interface{}, error) { - return burnFromExported(raw, rawReturn, &datacap.BurnFromParams{}, &datacap.BurnFromReturn{}) + return burnGeneric(raw, rawReturn, &datacapv11.BurnFromParams{}, &datacapv11.BurnFromReturn{}) +} + +func burnFromExportedv12(raw, rawReturn []byte) (map[string]interface{}, error) { + return burnGeneric(raw, rawReturn, &datacapv12.BurnFromParams{}, &datacapv12.BurnFromReturn{}) +} + +func burnFromExportedv13(raw, rawReturn []byte) (map[string]interface{}, error) { + return burnGeneric(raw, rawReturn, &datacapv13.BurnFromParams{}, &datacapv13.BurnFromReturn{}) } func burnFromExportedv14(raw, rawReturn []byte) (map[string]interface{}, error) { - return burnFromExported(raw, rawReturn, &datacap.BurnFromParams{}, &datacap.BurnFromReturn{}) + return burnGeneric(raw, rawReturn, &datacapv14.BurnFromParams{}, &datacapv14.BurnFromReturn{}) +} + +func burnFromExportedv15(raw, rawReturn []byte) (map[string]interface{}, error) { + return burnGeneric(raw, rawReturn, &datacapv15.BurnFromParams{}, &datacapv15.BurnFromReturn{}) } diff --git a/actors/datacap/datacap.go b/actors/datacap/datacap.go index 19375922..ac78936a 100644 --- a/actors/datacap/datacap.go +++ b/actors/datacap/datacap.go @@ -12,10 +12,10 @@ type unmarshalCBOR interface { UnmarshalCBOR(io.Reader) error } -func NameExported(rawReturn []byte) (map[string]interface{}, error) { +func datacapGeneric[T unmarshalCBOR](rawReturn []byte) (map[string]interface{}, error) { metadata := make(map[string]interface{}) reader := bytes.NewReader(rawReturn) - var r abi.CborString + var r T err := r.UnmarshalCBOR(reader) if err != nil { return metadata, err @@ -24,26 +24,14 @@ func NameExported(rawReturn []byte) (map[string]interface{}, error) { return metadata, nil } +func NameExported(rawReturn []byte) (map[string]interface{}, error) { + return datacapGeneric[*abi.CborString](rawReturn) +} + func SymbolExported(rawReturn []byte) (map[string]interface{}, error) { - metadata := make(map[string]interface{}) - reader := bytes.NewReader(rawReturn) - var r abi.CborString - err := r.UnmarshalCBOR(reader) - if err != nil { - return metadata, err - } - metadata[parser.ReturnKey] = r - return metadata, nil + return datacapGeneric[*abi.CborString](rawReturn) } func TotalSupplyExported(rawReturn []byte) (map[string]interface{}, error) { - metadata := make(map[string]interface{}) - reader := bytes.NewReader(rawReturn) - var r abi.TokenAmount - err := r.UnmarshalCBOR(reader) - if err != nil { - return metadata, err - } - metadata[parser.ReturnKey] = r // TODO: .uint64()?? - return metadata, nil + return datacapGeneric[*abi.TokenAmount](rawReturn) } diff --git a/actors/datacap/granularity.go b/actors/datacap/granularity.go index 225e1553..11fb1145 100644 --- a/actors/datacap/granularity.go +++ b/actors/datacap/granularity.go @@ -2,14 +2,40 @@ package datacap import ( "bytes" + "fmt" - "github.com/filecoin-project/go-state-types/builtin/v10/datacap" + datacapv10 "github.com/filecoin-project/go-state-types/builtin/v10/datacap" + datacapv11 "github.com/filecoin-project/go-state-types/builtin/v11/datacap" + datacapv12 "github.com/filecoin-project/go-state-types/builtin/v12/datacap" + datacapv13 "github.com/filecoin-project/go-state-types/builtin/v13/datacap" + datacapv14 "github.com/filecoin-project/go-state-types/builtin/v14/datacap" + datacapv15 "github.com/filecoin-project/go-state-types/builtin/v15/datacap" "github.com/zondax/fil-parser/parser" ) type granularityReturn = unmarshalCBOR -func granularityExported(rawReturn []byte, r granularityReturn) (map[string]interface{}, error) { +func GranularityExported(height uint64, rawReturn []byte) (map[string]interface{}, error) { + switch height { + case 9: + return nil, fmt.Errorf("not supported") + case 10: + return granularityExportedv10(rawReturn) + case 11: + return granularityExportedv11(rawReturn) + case 12: + return granularityExportedv12(rawReturn) + case 13: + return granularityExportedv13(rawReturn) + case 14: + return granularityExportedv14(rawReturn) + case 15: + return granularityExportedv15(rawReturn) + } + return nil, fmt.Errorf("not supported") +} + +func granularityGeneric[T granularityReturn](rawReturn []byte, r T) (map[string]interface{}, error) { metadata := make(map[string]interface{}) reader := bytes.NewReader(rawReturn) err := r.UnmarshalCBOR(reader) @@ -20,10 +46,34 @@ func granularityExported(rawReturn []byte, r granularityReturn) (map[string]inte return metadata, nil } +// Granularity Exported + +func granularityExportedv10(rawReturn []byte) (map[string]interface{}, error) { + var r datacapv10.GranularityReturn + return granularityGeneric[*datacapv10.GranularityReturn](rawReturn, &r) +} + func granularityExportedv11(rawReturn []byte) (map[string]interface{}, error) { - return granularityExported(rawReturn, datacap.GranularityReturn{}) + var r datacapv11.GranularityReturn + return granularityGeneric[*datacapv11.GranularityReturn](rawReturn, &r) +} + +func granularityExportedv12(rawReturn []byte) (map[string]interface{}, error) { + var r datacapv12.GranularityReturn + return granularityGeneric[*datacapv12.GranularityReturn](rawReturn, &r) +} + +func granularityExportedv13(rawReturn []byte) (map[string]interface{}, error) { + var r datacapv13.GranularityReturn + return granularityGeneric[*datacapv13.GranularityReturn](rawReturn, &r) } func granularityExportedv14(rawReturn []byte) (map[string]interface{}, error) { - return granularityExported(rawReturn, datacap.GranularityReturn{}) + var r datacapv14.GranularityReturn + return granularityGeneric[*datacapv14.GranularityReturn](rawReturn, &r) +} + +func granularityExportedv15(rawReturn []byte) (map[string]interface{}, error) { + var r datacapv15.GranularityReturn + return granularityGeneric[*datacapv15.GranularityReturn](rawReturn, &r) } diff --git a/actors/datacap/mint.go b/actors/datacap/mint.go index 6b3a5ead..6cfe9003 100644 --- a/actors/datacap/mint.go +++ b/actors/datacap/mint.go @@ -2,8 +2,15 @@ package datacap import ( "bytes" + "fmt" - "github.com/filecoin-project/go-state-types/builtin/v10/datacap" + datacapv10 "github.com/filecoin-project/go-state-types/builtin/v10/datacap" + datacapv11 "github.com/filecoin-project/go-state-types/builtin/v11/datacap" + datacapv12 "github.com/filecoin-project/go-state-types/builtin/v12/datacap" + datacapv13 "github.com/filecoin-project/go-state-types/builtin/v13/datacap" + datacapv14 "github.com/filecoin-project/go-state-types/builtin/v14/datacap" + datacapv15 "github.com/filecoin-project/go-state-types/builtin/v15/datacap" + datacapv9 "github.com/filecoin-project/go-state-types/builtin/v9/datacap" "github.com/zondax/fil-parser/parser" ) @@ -12,7 +19,27 @@ type ( mintReturn = unmarshalCBOR ) -func mintExported(raw, rawReturn []byte, params mintParams, r mintReturn) (map[string]interface{}, error) { +func MintExported(height uint64, raw, rawReturn []byte) (map[string]interface{}, error) { + switch height { + case 9: + return mintExportedv9(raw, rawReturn) + case 10: + return mintExportedv10(raw, rawReturn) + case 11: + return mintExportedv11(raw, rawReturn) + case 12: + return mintExportedv12(raw, rawReturn) + case 13: + return mintExportedv13(raw, rawReturn) + case 14: + return mintExportedv14(raw, rawReturn) + case 15: + return mintExportedv15(raw, rawReturn) + } + return nil, fmt.Errorf("not supported") +} + +func mintGeneric[P mintParams, R mintReturn](raw, rawReturn []byte, params P, r R) (map[string]interface{}, error) { metadata := make(map[string]interface{}) reader := bytes.NewReader(raw) err := params.UnmarshalCBOR(reader) @@ -30,10 +57,30 @@ func mintExported(raw, rawReturn []byte, params mintParams, r mintReturn) (map[s return metadata, nil } +func mintExportedv9(raw, rawReturn []byte) (map[string]interface{}, error) { + return mintGeneric[*datacapv9.MintParams, *datacapv9.MintReturn](raw, rawReturn, &datacapv9.MintParams{}, &datacapv9.MintReturn{}) +} + +func mintExportedv10(raw, rawReturn []byte) (map[string]interface{}, error) { + return mintGeneric[*datacapv10.MintParams, *datacapv10.MintReturn](raw, rawReturn, &datacapv10.MintParams{}, &datacapv10.MintReturn{}) +} + func mintExportedv11(raw, rawReturn []byte) (map[string]interface{}, error) { - return mintExported(raw, rawReturn, &datacap.MintParams{}, &datacap.MintReturn{}) + return mintGeneric[*datacapv11.MintParams, *datacapv11.MintReturn](raw, rawReturn, &datacapv11.MintParams{}, &datacapv11.MintReturn{}) +} + +func mintExportedv12(raw, rawReturn []byte) (map[string]interface{}, error) { + return mintGeneric[*datacapv12.MintParams, *datacapv12.MintReturn](raw, rawReturn, &datacapv12.MintParams{}, &datacapv12.MintReturn{}) +} + +func mintExportedv13(raw, rawReturn []byte) (map[string]interface{}, error) { + return mintGeneric[*datacapv13.MintParams, *datacapv13.MintReturn](raw, rawReturn, &datacapv13.MintParams{}, &datacapv13.MintReturn{}) } func mintExportedv14(raw, rawReturn []byte) (map[string]interface{}, error) { - return mintExported(raw, rawReturn, &datacap.MintParams{}, &datacap.MintReturn{}) + return mintGeneric[*datacapv14.MintParams, *datacapv14.MintReturn](raw, rawReturn, &datacapv14.MintParams{}, &datacapv14.MintReturn{}) +} + +func mintExportedv15(raw, rawReturn []byte) (map[string]interface{}, error) { + return mintGeneric[*datacapv15.MintParams, *datacapv15.MintReturn](raw, rawReturn, &datacapv15.MintParams{}, &datacapv15.MintReturn{}) } diff --git a/actors/datacap/transfer.go b/actors/datacap/transfer.go index eed7d64e..079ed3f7 100644 --- a/actors/datacap/transfer.go +++ b/actors/datacap/transfer.go @@ -2,8 +2,15 @@ package datacap import ( "bytes" + "fmt" - "github.com/filecoin-project/go-state-types/builtin/v10/datacap" + datacapv10 "github.com/filecoin-project/go-state-types/builtin/v10/datacap" + datacapv11 "github.com/filecoin-project/go-state-types/builtin/v11/datacap" + datacapv12 "github.com/filecoin-project/go-state-types/builtin/v12/datacap" + datacapv13 "github.com/filecoin-project/go-state-types/builtin/v13/datacap" + datacapv14 "github.com/filecoin-project/go-state-types/builtin/v14/datacap" + datacapv15 "github.com/filecoin-project/go-state-types/builtin/v15/datacap" + datacapv9 "github.com/filecoin-project/go-state-types/builtin/v9/datacap" "github.com/zondax/fil-parser/parser" ) @@ -14,7 +21,34 @@ type ( transferFromReturn = unmarshalCBOR ) -func transferExported(raw, rawReturn []byte, params transferParams, r transferReturn) (map[string]interface{}, error) { +type transferParamsInterface interface { + unmarshalCBOR +} +type transferReturnInterface interface { + unmarshalCBOR +} + +func TransferExported(height uint64, raw, rawReturn []byte) (map[string]interface{}, error) { + switch height { + case 9: + return transferExportedv9(raw, rawReturn) + case 10: + return transferExportedv10(raw, rawReturn) + case 11: + return transferExportedv11(raw, rawReturn) + case 12: + return transferExportedv12(raw, rawReturn) + case 13: + return transferExportedv13(raw, rawReturn) + case 14: + return transferExportedv14(raw, rawReturn) + case 15: + return transferExportedv15(raw, rawReturn) + } + return nil, fmt.Errorf("not supported") +} + +func transferGeneric[P transferParamsInterface, R transferReturnInterface](raw, rawReturn []byte, params P, r R) (map[string]interface{}, error) { metadata := make(map[string]interface{}) reader := bytes.NewReader(raw) err := params.UnmarshalCBOR(reader) @@ -32,36 +66,30 @@ func transferExported(raw, rawReturn []byte, params transferParams, r transferRe return metadata, nil } -func transferExportedv11(raw, rawReturn []byte) (map[string]interface{}, error) { - return transferExported(raw, rawReturn, &datacap.TransferParams{}, &datacap.TransferReturn{}) +func transferExportedv9(raw, rawReturn []byte) (map[string]interface{}, error) { + return transferGeneric[*datacapv9.TransferParams, *datacapv9.TransferReturn](raw, rawReturn, &datacapv9.TransferParams{}, &datacapv9.TransferReturn{}) } -func transferExportedv14(raw, rawReturn []byte) (map[string]interface{}, error) { - return transferExported(raw, rawReturn, &datacap.TransferParams{}, &datacap.TransferReturn{}) +func transferExportedv10(raw, rawReturn []byte) (map[string]interface{}, error) { + return transferGeneric[*datacapv10.TransferParams, *datacapv10.TransferReturn](raw, rawReturn, &datacapv10.TransferParams{}, &datacapv10.TransferReturn{}) } -func transferFromExported(raw, rawReturn []byte, params transferFromParams, r transferFromReturn) (map[string]interface{}, error) { - metadata := make(map[string]interface{}) - reader := bytes.NewReader(raw) - err := params.UnmarshalCBOR(reader) - if err != nil { - return metadata, err - } - metadata[parser.ParamsKey] = params +func transferExportedv11(raw, rawReturn []byte) (map[string]interface{}, error) { + return transferGeneric[*datacapv11.TransferParams, *datacapv11.TransferReturn](raw, rawReturn, &datacapv11.TransferParams{}, &datacapv11.TransferReturn{}) +} - reader = bytes.NewReader(rawReturn) - err = r.UnmarshalCBOR(reader) - if err != nil { - return metadata, err - } - metadata[parser.ReturnKey] = r - return metadata, nil +func transferExportedv12(raw, rawReturn []byte) (map[string]interface{}, error) { + return transferGeneric[*datacapv12.TransferParams, *datacapv12.TransferReturn](raw, rawReturn, &datacapv12.TransferParams{}, &datacapv12.TransferReturn{}) } -func transferFromExportedv11(raw, rawReturn []byte) (map[string]interface{}, error) { - return transferFromExported(raw, rawReturn, &datacap.TransferFromParams{}, &datacap.TransferFromReturn{}) +func transferExportedv13(raw, rawReturn []byte) (map[string]interface{}, error) { + return transferGeneric[*datacapv13.TransferParams, *datacapv13.TransferReturn](raw, rawReturn, &datacapv13.TransferParams{}, &datacapv13.TransferReturn{}) +} + +func transferExportedv14(raw, rawReturn []byte) (map[string]interface{}, error) { + return transferGeneric[*datacapv14.TransferParams, *datacapv14.TransferReturn](raw, rawReturn, &datacapv14.TransferParams{}, &datacapv14.TransferReturn{}) } -func transferFromExportedv14(raw, rawReturn []byte) (map[string]interface{}, error) { - return transferFromExported(raw, rawReturn, &datacap.TransferFromParams{}, &datacap.TransferFromReturn{}) +func transferExportedv15(raw, rawReturn []byte) (map[string]interface{}, error) { + return transferGeneric[*datacapv15.TransferParams, *datacapv15.TransferReturn](raw, rawReturn, &datacapv15.TransferParams{}, &datacapv15.TransferReturn{}) } diff --git a/actors/eam/return.go b/actors/eam/return.go new file mode 100644 index 00000000..6280e813 --- /dev/null +++ b/actors/eam/return.go @@ -0,0 +1,261 @@ +package eam + +import ( + "bytes" + "encoding/hex" + "fmt" + "io" + "strconv" + + "github.com/filecoin-project/go-address" + "github.com/filecoin-project/go-state-types/abi" + eamv10 "github.com/filecoin-project/go-state-types/builtin/v10/eam" + eamv11 "github.com/filecoin-project/go-state-types/builtin/v11/eam" + eamv12 "github.com/filecoin-project/go-state-types/builtin/v12/eam" + eamv13 "github.com/filecoin-project/go-state-types/builtin/v13/eam" + eamv14 "github.com/filecoin-project/go-state-types/builtin/v14/eam" + eamv15 "github.com/filecoin-project/go-state-types/builtin/v15/eam" + eamv9 "github.com/filecoin-project/go-state-types/builtin/v9/eam" + "github.com/filecoin-project/lotus/chain/types/ethtypes" + "github.com/ipfs/go-cid" + "github.com/zondax/fil-parser/parser" + "github.com/zondax/fil-parser/types" +) + +type createReturn interface { + UnmarshalCBOR(io.Reader) error +} + +type createReturnStruct[T any] struct { + CreateReturn T +} + +func parseEamReturn[R createReturn](rawReturn []byte) (R, error) { + var cr R + + reader := bytes.NewReader(rawReturn) + err := cr.UnmarshalCBOR(reader) + if err != nil { + return cr, err + } + + err = validateEamReturn(cr) + if err != nil { + rawString := hex.EncodeToString(rawReturn) + return cr, fmt.Errorf("[parseEamReturn]- Detected invalid return bytes: %s. Raw: %s", err, rawString) + } + + return cr, nil +} + +func ParseEamReturn(height int64, rawReturn []byte) (any, error) { + switch height { + case 15: + return parseEamReturn[*eamv15.CreateReturn](rawReturn) + case 14: + return parseEamReturn[*eamv14.CreateReturn](rawReturn) + case 13: + return parseEamReturn[*eamv13.CreateReturn](rawReturn) + case 12: + return parseEamReturn[*eamv12.CreateReturn](rawReturn) + case 11: + return parseEamReturn[*eamv11.CreateReturn](rawReturn) + case 10: + return parseEamReturn[*eamv10.CreateReturn](rawReturn) + case 9: + return parseEamReturn[*eamv9.CreateReturn](rawReturn) + } + return nil, fmt.Errorf("unsupported height: %d", height) +} + +func ParseCreateExternal(height int64, rawParams, rawReturn []byte, msgCid cid.Cid) (map[string]interface{}, *types.AddressInfo, error) { + external := true + switch height { + case 15: + return parseCreate[*eamv15.CreateExternalReturn](rawParams, rawReturn, msgCid, external) + case 14: + return parseCreate[*eamv14.CreateExternalReturn](rawParams, rawReturn, msgCid, external) + case 13: + return parseCreate[*eamv13.CreateExternalReturn](rawParams, rawReturn, msgCid, external) + case 12: + return parseCreate[*eamv12.CreateExternalReturn](rawParams, rawReturn, msgCid, external) + case 11: + return parseCreate[*eamv11.CreateExternalReturn](rawParams, rawReturn, msgCid, external) + case 10: + return parseCreate[*eamv10.CreateExternalReturn](rawParams, rawReturn, msgCid, external) + case 9: + return parseCreate[*eamv9.CreateExternalReturn](rawParams, rawReturn, msgCid, external) + } + return nil, nil, fmt.Errorf("unsupported height: %d", height) +} + +func ParseCreate(height int64, rawParams, rawReturn []byte, msgCid cid.Cid) (map[string]interface{}, *types.AddressInfo, error) { + external := false + switch height { + case 15: + return parseCreate[*eamv15.CreateReturn](rawParams, rawReturn, msgCid, external) + case 14: + return parseCreate[*eamv14.CreateReturn](rawParams, rawReturn, msgCid, external) + case 13: + return parseCreate[*eamv13.CreateReturn](rawParams, rawReturn, msgCid, external) + case 12: + return parseCreate[*eamv12.CreateReturn](rawParams, rawReturn, msgCid, external) + case 11: + return parseCreate[*eamv11.CreateReturn](rawParams, rawReturn, msgCid, external) + case 10: + return parseCreate[*eamv10.CreateReturn](rawParams, rawReturn, msgCid, external) + case 9: + return parseCreate[*eamv9.CreateReturn](rawParams, rawReturn, msgCid, external) + } + return nil, nil, fmt.Errorf("unsupported height: %d", height) +} + +func ParseCreate2(height int64, rawParams, rawReturn []byte, msgCid cid.Cid) (map[string]interface{}, *types.AddressInfo, error) { + external := false + switch height { + case 15: + return parseCreate[*eamv15.Create2Return](rawParams, rawReturn, msgCid, external) + case 14: + return parseCreate[*eamv14.Create2Return](rawParams, rawReturn, msgCid, external) + case 13: + return parseCreate[*eamv13.Create2Return](rawParams, rawReturn, msgCid, external) + case 12: + return parseCreate[*eamv12.Create2Return](rawParams, rawReturn, msgCid, external) + case 11: + return parseCreate[*eamv11.Create2Return](rawParams, rawReturn, msgCid, external) + case 10: + return parseCreate[*eamv10.Create2Return](rawParams, rawReturn, msgCid, external) + case 9: + return parseCreate[*eamv9.Create2Return](rawParams, rawReturn, msgCid, external) + } + return nil, nil, fmt.Errorf("unsupported height: %d", height) +} + +func newEamCreate(r createReturn) parser.EamCreateReturn { + switch v := r.(type) { + case *eamv15.CreateReturn: + return parser.EamCreateReturn{ + ActorId: v.ActorID, + RobustAddress: v.RobustAddress, + EthAddress: parser.EthPrefix + hex.EncodeToString(v.EthAddress[:]), + } + case *eamv14.CreateReturn: + return parser.EamCreateReturn{ + ActorId: v.ActorID, + RobustAddress: v.RobustAddress, + EthAddress: parser.EthPrefix + hex.EncodeToString(v.EthAddress[:]), + } + case *eamv13.CreateReturn: + return parser.EamCreateReturn{ + ActorId: v.ActorID, + RobustAddress: v.RobustAddress, + EthAddress: parser.EthPrefix + hex.EncodeToString(v.EthAddress[:]), + } + case *eamv12.CreateReturn: + return parser.EamCreateReturn{ + ActorId: v.ActorID, + RobustAddress: v.RobustAddress, + EthAddress: parser.EthPrefix + hex.EncodeToString(v.EthAddress[:]), + } + case *eamv11.CreateReturn: + return parser.EamCreateReturn{ + ActorId: v.ActorID, + RobustAddress: v.RobustAddress, + EthAddress: parser.EthPrefix + hex.EncodeToString(v.EthAddress[:]), + } + case *eamv10.CreateReturn: + return parser.EamCreateReturn{ + ActorId: v.ActorID, + RobustAddress: v.RobustAddress, + EthAddress: parser.EthPrefix + hex.EncodeToString(v.EthAddress[:]), + } + case *eamv9.CreateReturn: + return parser.EamCreateReturn{ + ActorId: v.ActorID, + RobustAddress: v.RobustAddress, + EthAddress: parser.EthPrefix + hex.EncodeToString(v.EthAddress[:]), + } + default: + return parser.EamCreateReturn{} + } +} + +func validateEamReturn(ret createReturn) error { + if ret == nil { + return fmt.Errorf("input is nil") + } + + checkAndSetAddress := func(addr **address.Address) error { + if *addr == nil { + emptyAdd, _ := address.NewFromString("") + *addr = &emptyAdd + return fmt.Errorf("RobustAddress field is nil. Replaced with empty address") + } + return nil + } + + switch v := ret.(type) { + case *eamv15.CreateReturn: + return checkAndSetAddress(&v.RobustAddress) + case *eamv14.CreateReturn: + return checkAndSetAddress(&v.RobustAddress) + case *eamv13.CreateReturn: + return checkAndSetAddress(&v.RobustAddress) + case *eamv12.CreateReturn: + return checkAndSetAddress(&v.RobustAddress) + case *eamv11.CreateReturn: + return checkAndSetAddress(&v.RobustAddress) + case *eamv10.CreateReturn: + return checkAndSetAddress(&v.RobustAddress) + case *eamv9.CreateReturn: + return checkAndSetAddress(&v.RobustAddress) + } + + return nil +} + +func parseCreate[T createReturn](rawParams, rawReturn []byte, msgCid cid.Cid, isExternal bool) (map[string]interface{}, *types.AddressInfo, error) { + metadata := make(map[string]interface{}) + reader := bytes.NewReader(rawParams) + + if isExternal { + metadata[parser.ParamsKey] = parser.EthPrefix + hex.EncodeToString(rawParams) + var params abi.CborBytes + if err := params.UnmarshalCBOR(reader); err != nil { + return metadata, nil, fmt.Errorf("error deserializing rawParams: %s - hex data: %s", err.Error(), hex.EncodeToString(rawParams)) + } + + if reader.Len() == 0 { // This means that the reader has processed all the bytes + metadata[parser.ParamsKey] = parser.EthPrefix + hex.EncodeToString(params) + } + } else { + var params T + err := params.UnmarshalCBOR(reader) + if err != nil { + return metadata, nil, err + } + } + + createReturn, err := parseEamReturn[T](rawReturn) + if err != nil { + return metadata, nil, err + } + + metadata[parser.ReturnKey] = newEamCreate(createReturn) + + ethHash, err := ethtypes.EthHashFromCid(msgCid) + if err != nil { + return metadata, nil, err + } + metadata[parser.EthHashKey] = ethHash.String() + + r := newEamCreate(createReturn) + createdEvmActor := &types.AddressInfo{ + Short: parser.FilPrefix + strconv.FormatUint(r.ActorId, 10), + Robust: r.RobustAddress.String(), + EthAddress: parser.EthPrefix + r.EthAddress, + ActorType: "evm", + CreationTxCid: msgCid.String(), + } + return metadata, createdEvmActor, nil +} diff --git a/actors/evm/evm.go b/actors/evm/evm.go new file mode 100644 index 00000000..505f25af --- /dev/null +++ b/actors/evm/evm.go @@ -0,0 +1,211 @@ +package evm + +import ( + "bytes" + "encoding/hex" + "fmt" + "io" + + "github.com/filecoin-project/go-state-types/abi" + evmv10 "github.com/filecoin-project/go-state-types/builtin/v10/evm" + evmv11 "github.com/filecoin-project/go-state-types/builtin/v11/evm" + evmv12 "github.com/filecoin-project/go-state-types/builtin/v12/evm" + evmv13 "github.com/filecoin-project/go-state-types/builtin/v13/evm" + evmv14 "github.com/filecoin-project/go-state-types/builtin/v14/evm" + evmv15 "github.com/filecoin-project/go-state-types/builtin/v15/evm" + "github.com/zondax/fil-parser/parser" +) + +type evmParams interface { + UnmarshalCBOR(io.Reader) error +} + +type evmReturn interface { + UnmarshalCBOR(io.Reader) error +} + +func InvokeContract(rawParams, rawReturn []byte) (map[string]interface{}, error) { + metadata := make(map[string]interface{}) + reader := bytes.NewReader(rawParams) + metadata[parser.ParamsKey] = parser.EthPrefix + hex.EncodeToString(rawParams) + metadata[parser.ReturnKey] = parser.EthPrefix + hex.EncodeToString(rawReturn) + + var params abi.CborBytes + if err := params.UnmarshalCBOR(reader); err != nil { + return metadata, fmt.Errorf("error deserializing rawParams: %s - hex data: %s", err.Error(), hex.EncodeToString(rawParams)) + } + + if reader.Len() == 0 { // This means that the reader has processed all the bytes + metadata[parser.ParamsKey] = parser.EthPrefix + hex.EncodeToString(params) + } + + reader = bytes.NewReader(rawReturn) + var returnValue abi.CborBytes + if err := returnValue.UnmarshalCBOR(reader); err != nil { + return metadata, fmt.Errorf("error deserializing rawReturn: %s - hex data: %s", err.Error(), hex.EncodeToString(rawReturn)) + } + + if reader.Len() == 0 { // This means that the reader has processed all the bytes + metadata[parser.ReturnKey] = parser.EthPrefix + hex.EncodeToString(returnValue) + } + + return metadata, nil +} + +func Resurrect(height int64, raw []byte) (map[string]interface{}, error) { + switch height { + case 15: + return getByteCode[*evmv15.ResurrectParams](parser.ParamsKey, raw) + case 14: + return getByteCode[*evmv14.ResurrectParams](parser.ParamsKey, raw) + case 13: + return getByteCode[*evmv13.ResurrectParams](parser.ParamsKey, raw) + case 12: + return getByteCode[*evmv12.ResurrectParams](parser.ParamsKey, raw) + case 11: + return getByteCode[*evmv11.ResurrectParams](parser.ParamsKey, raw) + case 10: + return getByteCode[*evmv10.ResurrectParams](parser.ParamsKey, raw) + } + return nil, fmt.Errorf("unsupported height: %d", height) +} + +func InvokeContractDelegate(height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { + switch height { + case 15: + return invokeContractDelegate[*evmv15.DelegateCallParams, *abi.CborBytes](rawParams, rawReturn) + case 14: + return invokeContractDelegate[*evmv14.DelegateCallParams, *abi.CborBytes](rawParams, rawReturn) + case 13: + return invokeContractDelegate[*evmv13.DelegateCallParams, *abi.CborBytes](rawParams, rawReturn) + case 12: + return invokeContractDelegate[*evmv12.DelegateCallParams, *abi.CborBytes](rawParams, rawReturn) + case 11: + return invokeContractDelegate[*evmv11.DelegateCallParams, *abi.CborBytes](rawParams, rawReturn) + case 10: + return invokeContractDelegate[*evmv10.DelegateCallParams, *abi.CborBytes](rawParams, rawReturn) + } + return nil, fmt.Errorf("unsupported height: %d", height) +} + +func GetByteCode(height int64, raw []byte) (map[string]interface{}, error) { + switch height { + case 15: + return getByteCode[*evmv15.GetBytecodeReturn](parser.ReturnKey, raw) + case 14: + return getByteCode[*evmv14.GetBytecodeReturn](parser.ReturnKey, raw) + case 13: + return getByteCode[*evmv13.GetBytecodeReturn](parser.ReturnKey, raw) + case 12: + return getByteCode[*evmv12.GetBytecodeReturn](parser.ReturnKey, raw) + case 11: + return getByteCode[*evmv11.GetBytecodeReturn](parser.ReturnKey, raw) + case 10: + return getByteCode[*evmv10.GetBytecodeReturn](parser.ReturnKey, raw) + } + return nil, fmt.Errorf("unsupported height: %d", height) +} + +func GetByteCodeHash(height int64, raw []byte) (map[string]interface{}, error) { + switch height { + case 15: + return getByteCode[*abi.CborBytes](parser.ReturnKey, raw) + case 14: + return getByteCode[*abi.CborBytes](parser.ReturnKey, raw) + case 13: + return getByteCode[*abi.CborBytes](parser.ReturnKey, raw) + case 12: + return getByteCode[*abi.CborBytes](parser.ReturnKey, raw) + case 11: + return getByteCode[*abi.CborBytes](parser.ReturnKey, raw) + case 10: + return getByteCode[*abi.CborBytes](parser.ReturnKey, raw) + } + return nil, fmt.Errorf("unsupported height: %d", height) +} + +func EVMConstructor(height int64, raw []byte) (map[string]interface{}, error) { + switch height { + case 15: + return getByteCode[*evmv15.ConstructorParams](parser.ParamsKey, raw) + case 14: + return getByteCode[*evmv14.ConstructorParams](parser.ParamsKey, raw) + case 13: + return getByteCode[*evmv13.ConstructorParams](parser.ParamsKey, raw) + case 12: + return getByteCode[*evmv12.ConstructorParams](parser.ParamsKey, raw) + case 11: + return getByteCode[*evmv11.ConstructorParams](parser.ParamsKey, raw) + case 10: + return getByteCode[*evmv10.ConstructorParams](parser.ParamsKey, raw) + } + return nil, fmt.Errorf("unsupported height: %d", height) +} + +func GetStorageAt(height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { + switch height { + case 15: + return getStorageAt[*evmv15.GetStorageAtParams, *abi.CborBytes](rawParams, rawReturn) + case 14: + return getStorageAt[*evmv14.GetStorageAtParams, *abi.CborBytes](rawParams, rawReturn) + case 13: + return getStorageAt[*evmv13.GetStorageAtParams, *abi.CborBytes](rawParams, rawReturn) + case 12: + return getStorageAt[*evmv12.GetStorageAtParams, *abi.CborBytes](rawParams, rawReturn) + case 11: + return getStorageAt[*evmv11.GetStorageAtParams, *abi.CborBytes](rawParams, rawReturn) + case 10: + return getStorageAt[*evmv10.GetStorageAtParams, *abi.CborBytes](rawParams, rawReturn) + } + return nil, fmt.Errorf("unsupported height: %d", height) +} + +func invokeContractDelegate[T evmParams, R evmReturn](rawParams, rawReturn []byte) (map[string]interface{}, error) { + metadata := make(map[string]interface{}) + reader := bytes.NewReader(rawParams) + var params T + err := params.UnmarshalCBOR(reader) + if err != nil { + return metadata, err + } + metadata[parser.ParamsKey] = params + reader = bytes.NewReader(rawReturn) + var r R + err = r.UnmarshalCBOR(reader) + if err != nil { + return metadata, err + } + metadata[parser.ReturnKey] = r + return metadata, nil +} + +func getByteCode[R evmReturn](key string, raw []byte) (map[string]interface{}, error) { + metadata := make(map[string]interface{}) + reader := bytes.NewReader(raw) + var r R + err := r.UnmarshalCBOR(reader) + if err != nil { + return metadata, err + } + metadata[key] = r + return metadata, nil +} + +func getStorageAt[T evmParams, R evmReturn](rawParams, rawReturn []byte) (map[string]interface{}, error) { + metadata := make(map[string]interface{}) + reader := bytes.NewReader(rawParams) + var params T + err := params.UnmarshalCBOR(reader) + if err != nil { + return metadata, err + } + metadata[parser.ParamsKey] = params + reader = bytes.NewReader(rawReturn) + var r R + err = r.UnmarshalCBOR(reader) + if err != nil { + return metadata, err + } + metadata[parser.ReturnKey] = r + return metadata, nil +} diff --git a/actors/init/init.go b/actors/init/init.go new file mode 100644 index 00000000..977bdad8 --- /dev/null +++ b/actors/init/init.go @@ -0,0 +1,237 @@ +package init + +import ( + "bytes" + "encoding/base64" + "fmt" + "io" + + builtinInitv10 "github.com/filecoin-project/go-state-types/builtin/v10/init" + builtinInitv11 "github.com/filecoin-project/go-state-types/builtin/v11/init" + builtinInitv12 "github.com/filecoin-project/go-state-types/builtin/v12/init" + builtinInitv13 "github.com/filecoin-project/go-state-types/builtin/v13/init" + builtinInitv14 "github.com/filecoin-project/go-state-types/builtin/v14/init" + builtinInitv15 "github.com/filecoin-project/go-state-types/builtin/v15/init" + builtinInitv8 "github.com/filecoin-project/go-state-types/builtin/v8/init" + builtinInitv9 "github.com/filecoin-project/go-state-types/builtin/v9/init" + + "github.com/zondax/fil-parser/parser" + "github.com/zondax/fil-parser/types" +) + +type constructorParams interface { + UnmarshalCBOR(io.Reader) error +} + +type execReturn interface { + UnmarshalCBOR(io.Reader) error +} + +func execParams(params constructorParams) parser.ExecParams { + switch v := params.(type) { + case *builtinInitv15.ExecParams: + return parser.ExecParams{ + CodeCid: v.CodeCID.String(), + ConstructorParams: base64.StdEncoding.EncodeToString(v.ConstructorParams), + } + case *builtinInitv14.ExecParams: + return parser.ExecParams{ + CodeCid: v.CodeCID.String(), + ConstructorParams: base64.StdEncoding.EncodeToString(v.ConstructorParams), + } + case *builtinInitv13.ExecParams: + return parser.ExecParams{ + CodeCid: v.CodeCID.String(), + ConstructorParams: base64.StdEncoding.EncodeToString(v.ConstructorParams), + } + case *builtinInitv12.ExecParams: + return parser.ExecParams{ + CodeCid: v.CodeCID.String(), + ConstructorParams: base64.StdEncoding.EncodeToString(v.ConstructorParams), + } + case *builtinInitv11.ExecParams: + return parser.ExecParams{ + CodeCid: v.CodeCID.String(), + ConstructorParams: base64.StdEncoding.EncodeToString(v.ConstructorParams), + } + case *builtinInitv10.ExecParams: + return parser.ExecParams{ + CodeCid: v.CodeCID.String(), + ConstructorParams: base64.StdEncoding.EncodeToString(v.ConstructorParams), + } + case *builtinInitv9.ExecParams: + return parser.ExecParams{ + CodeCid: v.CodeCID.String(), + ConstructorParams: base64.StdEncoding.EncodeToString(v.ConstructorParams), + } + case *builtinInitv8.ExecParams: + return parser.ExecParams{ + CodeCid: v.CodeCID.String(), + ConstructorParams: base64.StdEncoding.EncodeToString(v.ConstructorParams), + } + } + return parser.ExecParams{} +} + +func returnParams(msg *parser.LotusMessage, actorCID string, params execReturn) *types.AddressInfo { + switch v := params.(type) { + case *builtinInitv15.ExecReturn: + return &types.AddressInfo{ + Short: v.IDAddress.String(), + Robust: v.RobustAddress.String(), + ActorCid: actorCID, + CreationTxCid: msg.Cid.String(), + } + case *builtinInitv14.ExecReturn: + return &types.AddressInfo{ + Short: v.IDAddress.String(), + Robust: v.RobustAddress.String(), + ActorCid: actorCID, + CreationTxCid: msg.Cid.String(), + } + case *builtinInitv13.ExecReturn: + return &types.AddressInfo{ + Short: v.IDAddress.String(), + Robust: v.RobustAddress.String(), + ActorCid: actorCID, + CreationTxCid: msg.Cid.String(), + } + case *builtinInitv12.ExecReturn: + return &types.AddressInfo{ + Short: v.IDAddress.String(), + Robust: v.RobustAddress.String(), + ActorCid: actorCID, + CreationTxCid: msg.Cid.String(), + } + case *builtinInitv11.ExecReturn: + return &types.AddressInfo{ + Short: v.IDAddress.String(), + Robust: v.RobustAddress.String(), + ActorCid: actorCID, + CreationTxCid: msg.Cid.String(), + } + case *builtinInitv10.ExecReturn: + return &types.AddressInfo{ + Short: v.IDAddress.String(), + Robust: v.RobustAddress.String(), + ActorCid: actorCID, + CreationTxCid: msg.Cid.String(), + } + case *builtinInitv9.ExecReturn: + return &types.AddressInfo{ + Short: v.IDAddress.String(), + Robust: v.RobustAddress.String(), + ActorCid: actorCID, + CreationTxCid: msg.Cid.String(), + } + case *builtinInitv8.ExecReturn: + return &types.AddressInfo{ + Short: v.IDAddress.String(), + Robust: v.RobustAddress.String(), + ActorCid: actorCID, + CreationTxCid: msg.Cid.String(), + } + } + return &types.AddressInfo{} +} + +func InitConstructor(height int64, raw []byte) (map[string]interface{}, error) { + switch height { + case 15: + return initConstructor[*builtinInitv15.ConstructorParams](raw) + case 14: + return initConstructor[*builtinInitv14.ConstructorParams](raw) + case 13: + return initConstructor[*builtinInitv13.ConstructorParams](raw) + case 12: + return initConstructor[*builtinInitv12.ConstructorParams](raw) + case 11: + return initConstructor[*builtinInitv11.ConstructorParams](raw) + case 10: + return initConstructor[*builtinInitv10.ConstructorParams](raw) + case 9: + return initConstructor[*builtinInitv9.ConstructorParams](raw) + case 8: + return initConstructor[*builtinInitv8.ConstructorParams](raw) + } + return nil, fmt.Errorf("unsupported height: %d", height) +} + +func ParseExec(height int64, msg *parser.LotusMessage, raw []byte) (map[string]interface{}, *types.AddressInfo, error) { + switch height { + case 15: + return parseExec[*builtinInitv15.ExecParams, *builtinInitv15.ExecReturn](msg, raw) + case 14: + return parseExec[*builtinInitv14.ExecParams, *builtinInitv14.ExecReturn](msg, raw) + case 13: + return parseExec[*builtinInitv13.ExecParams, *builtinInitv13.ExecReturn](msg, raw) + case 12: + return parseExec[*builtinInitv12.ExecParams, *builtinInitv12.ExecReturn](msg, raw) + case 11: + return parseExec[*builtinInitv11.ExecParams, *builtinInitv11.ExecReturn](msg, raw) + case 10: + return parseExec[*builtinInitv10.ExecParams, *builtinInitv10.ExecReturn](msg, raw) + case 9: + return parseExec[*builtinInitv9.ExecParams, *builtinInitv9.ExecReturn](msg, raw) + case 8: + return parseExec[*builtinInitv8.ExecParams, *builtinInitv8.ExecReturn](msg, raw) + } + return nil, nil, fmt.Errorf("unsupported height: %d", height) +} + +func ParseExec4(height int64, msg *parser.LotusMessage, raw []byte) (map[string]interface{}, *types.AddressInfo, error) { + switch height { + case 15: + return parseExec[*builtinInitv15.Exec4Params, *builtinInitv15.Exec4Return](msg, raw) + case 14: + return parseExec[*builtinInitv14.Exec4Params, *builtinInitv14.Exec4Return](msg, raw) + case 13: + return parseExec[*builtinInitv13.Exec4Params, *builtinInitv13.Exec4Return](msg, raw) + case 12: + return parseExec[*builtinInitv12.Exec4Params, *builtinInitv12.Exec4Return](msg, raw) + case 11: + return parseExec[*builtinInitv11.Exec4Params, *builtinInitv11.Exec4Return](msg, raw) + case 10: + return parseExec[*builtinInitv10.Exec4Params, *builtinInitv10.Exec4Return](msg, raw) + case 9: + return nil, nil, fmt.Errorf("unsupported height: %d", height) + case 8: + return nil, nil, fmt.Errorf("unsupported height: %d", height) + } + return nil, nil, fmt.Errorf("unsupported height: %d", height) +} + +func initConstructor[T constructorParams](raw []byte) (map[string]interface{}, error) { + metadata := make(map[string]interface{}) + reader := bytes.NewReader(raw) + var constructor T + err := constructor.UnmarshalCBOR(reader) + if err != nil { + return metadata, err + } + metadata[parser.ParamsKey] = constructor + return metadata, nil +} + +func parseExec[T constructorParams, R execReturn](msg *parser.LotusMessage, rawReturn []byte) (map[string]interface{}, *types.AddressInfo, error) { + metadata := make(map[string]interface{}) + reader := bytes.NewReader(msg.Params) + var params T + err := params.UnmarshalCBOR(reader) + if err != nil { + return metadata, nil, err + } + tmp := execParams(params) + metadata[parser.ParamsKey] = tmp + + reader = bytes.NewReader(rawReturn) + var r R + err = r.UnmarshalCBOR(reader) + if err != nil { + return metadata, nil, err + } + + createdActor := returnParams(msg, tmp.CodeCid, r) + metadata[parser.ReturnKey] = createdActor + return metadata, createdActor, nil +} diff --git a/actors/market/market.go b/actors/market/market.go new file mode 100644 index 00000000..0274b033 --- /dev/null +++ b/actors/market/market.go @@ -0,0 +1 @@ +package market From da87834c17025210b80a2d25a216e32ddbab6b64 Mon Sep 17 00:00:00 2001 From: Eric Mokaya Date: Tue, 21 Jan 2025 20:25:10 +0300 Subject: [PATCH 03/16] feat: finalize high level design --- actors/init/init.go | 109 ++--- actors/market/market.go | 448 ++++++++++++++++++++ actors/miner/address.go | 72 ++++ actors/miner/balance.go | 31 ++ actors/miner/miner.go | 235 ++++++++++ actors/miner/sector.go | 103 +++++ actors/multisig/multisig.go | 142 +++++++ actors/multisig/types.go | 81 ++++ actors/multisig/utils.go | 67 +++ actors/multisig/values.go | 228 ++++++++++ actors/multisig/verifier.go | 11 + actors/multisig_types.go | 18 +- actors/paymentChannel/paymentChannel.go | 76 ++++ actors/power/power.go | 182 ++++++++ actors/reward/reward.go | 55 +++ actors/verifiedRegistry/verifiedRegistry.go | 175 ++++++++ 16 files changed, 1954 insertions(+), 79 deletions(-) create mode 100644 actors/miner/address.go create mode 100644 actors/miner/balance.go create mode 100644 actors/miner/miner.go create mode 100644 actors/miner/sector.go create mode 100644 actors/multisig/multisig.go create mode 100644 actors/multisig/types.go create mode 100644 actors/multisig/utils.go create mode 100644 actors/multisig/values.go create mode 100644 actors/multisig/verifier.go create mode 100644 actors/paymentChannel/paymentChannel.go create mode 100644 actors/power/power.go create mode 100644 actors/reward/reward.go create mode 100644 actors/verifiedRegistry/verifiedRegistry.go diff --git a/actors/init/init.go b/actors/init/init.go index 977bdad8..e924d1d6 100644 --- a/actors/init/init.go +++ b/actors/init/init.go @@ -6,6 +6,7 @@ import ( "fmt" "io" + "github.com/filecoin-project/go-address" builtinInitv10 "github.com/filecoin-project/go-state-types/builtin/v10/init" builtinInitv11 "github.com/filecoin-project/go-state-types/builtin/v11/init" builtinInitv12 "github.com/filecoin-project/go-state-types/builtin/v12/init" @@ -14,6 +15,7 @@ import ( builtinInitv15 "github.com/filecoin-project/go-state-types/builtin/v15/init" builtinInitv8 "github.com/filecoin-project/go-state-types/builtin/v8/init" builtinInitv9 "github.com/filecoin-project/go-state-types/builtin/v9/init" + "github.com/ipfs/go-cid" "github.com/zondax/fil-parser/parser" "github.com/zondax/fil-parser/types" @@ -28,111 +30,62 @@ type execReturn interface { } func execParams(params constructorParams) parser.ExecParams { - switch v := params.(type) { - case *builtinInitv15.ExecParams: + setParams := func(codeCid cid.Cid, constructorParams []byte) parser.ExecParams { return parser.ExecParams{ - CodeCid: v.CodeCID.String(), - ConstructorParams: base64.StdEncoding.EncodeToString(v.ConstructorParams), + CodeCid: codeCid.String(), + ConstructorParams: base64.StdEncoding.EncodeToString(constructorParams), } + } + switch v := params.(type) { + case *builtinInitv15.ExecParams: + return setParams(v.CodeCID, v.ConstructorParams) case *builtinInitv14.ExecParams: - return parser.ExecParams{ - CodeCid: v.CodeCID.String(), - ConstructorParams: base64.StdEncoding.EncodeToString(v.ConstructorParams), - } + return setParams(v.CodeCID, v.ConstructorParams) case *builtinInitv13.ExecParams: - return parser.ExecParams{ - CodeCid: v.CodeCID.String(), - ConstructorParams: base64.StdEncoding.EncodeToString(v.ConstructorParams), - } + return setParams(v.CodeCID, v.ConstructorParams) case *builtinInitv12.ExecParams: - return parser.ExecParams{ - CodeCid: v.CodeCID.String(), - ConstructorParams: base64.StdEncoding.EncodeToString(v.ConstructorParams), - } + return setParams(v.CodeCID, v.ConstructorParams) case *builtinInitv11.ExecParams: - return parser.ExecParams{ - CodeCid: v.CodeCID.String(), - ConstructorParams: base64.StdEncoding.EncodeToString(v.ConstructorParams), - } + return setParams(v.CodeCID, v.ConstructorParams) case *builtinInitv10.ExecParams: - return parser.ExecParams{ - CodeCid: v.CodeCID.String(), - ConstructorParams: base64.StdEncoding.EncodeToString(v.ConstructorParams), - } + return setParams(v.CodeCID, v.ConstructorParams) case *builtinInitv9.ExecParams: - return parser.ExecParams{ - CodeCid: v.CodeCID.String(), - ConstructorParams: base64.StdEncoding.EncodeToString(v.ConstructorParams), - } + return setParams(v.CodeCID, v.ConstructorParams) case *builtinInitv8.ExecParams: - return parser.ExecParams{ - CodeCid: v.CodeCID.String(), - ConstructorParams: base64.StdEncoding.EncodeToString(v.ConstructorParams), - } + return setParams(v.CodeCID, v.ConstructorParams) } return parser.ExecParams{} } func returnParams(msg *parser.LotusMessage, actorCID string, params execReturn) *types.AddressInfo { - switch v := params.(type) { - case *builtinInitv15.ExecReturn: + setReturn := func(idAddress, robustAddress address.Address) *types.AddressInfo { return &types.AddressInfo{ - Short: v.IDAddress.String(), - Robust: v.RobustAddress.String(), + Short: idAddress.String(), + Robust: robustAddress.String(), ActorCid: actorCID, CreationTxCid: msg.Cid.String(), } + } + switch v := params.(type) { + case *builtinInitv15.ExecReturn: + return setReturn(v.IDAddress, v.RobustAddress) case *builtinInitv14.ExecReturn: - return &types.AddressInfo{ - Short: v.IDAddress.String(), - Robust: v.RobustAddress.String(), - ActorCid: actorCID, - CreationTxCid: msg.Cid.String(), - } + return setReturn(v.IDAddress, v.RobustAddress) case *builtinInitv13.ExecReturn: - return &types.AddressInfo{ - Short: v.IDAddress.String(), - Robust: v.RobustAddress.String(), - ActorCid: actorCID, - CreationTxCid: msg.Cid.String(), - } + return setReturn(v.IDAddress, v.RobustAddress) case *builtinInitv12.ExecReturn: - return &types.AddressInfo{ - Short: v.IDAddress.String(), - Robust: v.RobustAddress.String(), - ActorCid: actorCID, - CreationTxCid: msg.Cid.String(), - } + return setReturn(v.IDAddress, v.RobustAddress) case *builtinInitv11.ExecReturn: - return &types.AddressInfo{ - Short: v.IDAddress.String(), - Robust: v.RobustAddress.String(), - ActorCid: actorCID, - CreationTxCid: msg.Cid.String(), - } + return setReturn(v.IDAddress, v.RobustAddress) case *builtinInitv10.ExecReturn: - return &types.AddressInfo{ - Short: v.IDAddress.String(), - Robust: v.RobustAddress.String(), - ActorCid: actorCID, - CreationTxCid: msg.Cid.String(), - } + return setReturn(v.IDAddress, v.RobustAddress) case *builtinInitv9.ExecReturn: - return &types.AddressInfo{ - Short: v.IDAddress.String(), - Robust: v.RobustAddress.String(), - ActorCid: actorCID, - CreationTxCid: msg.Cid.String(), - } + return setReturn(v.IDAddress, v.RobustAddress) case *builtinInitv8.ExecReturn: - return &types.AddressInfo{ - Short: v.IDAddress.String(), - Robust: v.RobustAddress.String(), - ActorCid: actorCID, - CreationTxCid: msg.Cid.String(), - } + return setReturn(v.IDAddress, v.RobustAddress) } return &types.AddressInfo{} + } func InitConstructor(height int64, raw []byte) (map[string]interface{}, error) { diff --git a/actors/market/market.go b/actors/market/market.go index 0274b033..ed0e0fd1 100644 --- a/actors/market/market.go +++ b/actors/market/market.go @@ -1 +1,449 @@ package market + +import ( + "bytes" + "fmt" + "io" + + "github.com/filecoin-project/go-address" + v10Market "github.com/filecoin-project/go-state-types/builtin/v10/market" + v11Market "github.com/filecoin-project/go-state-types/builtin/v11/market" + v12Market "github.com/filecoin-project/go-state-types/builtin/v12/market" + v13Market "github.com/filecoin-project/go-state-types/builtin/v13/market" + v14Market "github.com/filecoin-project/go-state-types/builtin/v14/market" + v15Market "github.com/filecoin-project/go-state-types/builtin/v15/market" + v8Market "github.com/filecoin-project/go-state-types/builtin/v8/market" + v9Market "github.com/filecoin-project/go-state-types/builtin/v9/market" + + "github.com/zondax/fil-parser/parser" +) + +type marketParam interface { + UnmarshalCBOR(io.Reader) error +} + +type marketReturn interface { + UnmarshalCBOR(io.Reader) error +} + +func getAddressAsString(addr any) string { + if address, ok := addr.(address.Address); ok { + return address.String() + } + return "" +} + +func parseGeneric[T marketParam, R marketReturn](rawParams, rawReturn []byte, returnCustomParam bool) (map[string]interface{}, error) { + metadata := make(map[string]interface{}) + reader := bytes.NewReader(rawParams) + var params T + err := params.UnmarshalCBOR(reader) + if err != nil { + return metadata, err + } + + metadata[parser.ParamsKey] = params + if !returnCustomParam { + metadata[parser.ParamsKey] = getAddressAsString(params) + return metadata, nil + } + + reader = bytes.NewReader(rawReturn) + var publishReturn R + err = publishReturn.UnmarshalCBOR(reader) + if err != nil { + return metadata, err + } + metadata[parser.ReturnKey] = publishReturn + return metadata, nil +} + +func ParseAddBalance(height int64, rawParams []byte) (map[string]interface{}, error) { + switch height { + case 15: + return parseGeneric[*address.Address, *address.Address](rawParams, nil, false) + case 14: + return parseGeneric[*address.Address, *address.Address](rawParams, nil, false) + case 13: + return parseGeneric[*address.Address, *address.Address](rawParams, nil, false) + case 12: + return parseGeneric[*address.Address, *address.Address](rawParams, nil, false) + case 11: + return parseGeneric[*address.Address, *address.Address](rawParams, nil, false) + case 10: + return parseGeneric[*address.Address, *address.Address](rawParams, nil, false) + } + return nil, fmt.Errorf("unsupported height: %d", height) +} +func ParseWithdrawBalance(height int64, rawParams []byte) (map[string]interface{}, error) { + switch height { + case 15: + return parseGeneric[*v15Market.WithdrawBalanceParams, *v15Market.WithdrawBalanceParams](rawParams, nil, false) + case 14: + return parseGeneric[*v14Market.WithdrawBalanceParams, *v14Market.WithdrawBalanceParams](rawParams, nil, false) + case 13: + return parseGeneric[*v13Market.WithdrawBalanceParams, *v13Market.WithdrawBalanceParams](rawParams, nil, false) + case 12: + return parseGeneric[*v12Market.WithdrawBalanceParams, *v12Market.WithdrawBalanceParams](rawParams, nil, false) + case 11: + return parseGeneric[*v11Market.WithdrawBalanceParams, *v11Market.WithdrawBalanceParams](rawParams, nil, false) + case 10: + return parseGeneric[*v10Market.WithdrawBalanceParams, *v10Market.WithdrawBalanceParams](rawParams, nil, false) + case 9: + return parseGeneric[*v9Market.WithdrawBalanceParams, *v9Market.WithdrawBalanceParams](rawParams, nil, false) + case 8: + return parseGeneric[*v8Market.WithdrawBalanceParams, *v8Market.WithdrawBalanceParams](rawParams, nil, false) + } + return nil, fmt.Errorf("unsupported height: %d", height) +} + +func PublishStorageDealsParams(height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { + switch height { + case 15: + return parseGeneric[*v15Market.PublishStorageDealsParams, *v15Market.PublishStorageDealsReturn](rawParams, rawReturn, true) + case 14: + return parseGeneric[*v14Market.PublishStorageDealsParams, *v14Market.PublishStorageDealsReturn](rawParams, rawReturn, true) + case 13: + return parseGeneric[*v13Market.PublishStorageDealsParams, *v13Market.PublishStorageDealsReturn](rawParams, rawReturn, true) + case 12: + return parseGeneric[*v12Market.PublishStorageDealsParams, *v12Market.PublishStorageDealsReturn](rawParams, rawReturn, true) + case 11: + return parseGeneric[*v11Market.PublishStorageDealsParams, *v11Market.PublishStorageDealsReturn](rawParams, rawReturn, true) + case 10: + return parseGeneric[*v10Market.PublishStorageDealsParams, *v10Market.PublishStorageDealsReturn](rawParams, rawReturn, true) + case 9: + return parseGeneric[*v9Market.PublishStorageDealsParams, *v9Market.PublishStorageDealsReturn](rawParams, rawReturn, true) + case 8: + return parseGeneric[*v8Market.PublishStorageDealsParams, *v8Market.PublishStorageDealsReturn](rawParams, rawReturn, true) + } + return nil, fmt.Errorf("unsupported height: %d", height) +} +func VerifyDealsForActivationParams(height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { + switch height { + case 15: + return parseGeneric[*v15Market.VerifyDealsForActivationParams, *v15Market.VerifyDealsForActivationReturn](rawParams, rawReturn, true) + case 14: + return parseGeneric[*v14Market.VerifyDealsForActivationParams, *v14Market.VerifyDealsForActivationReturn](rawParams, rawReturn, true) + case 13: + return parseGeneric[*v13Market.VerifyDealsForActivationParams, *v13Market.VerifyDealsForActivationReturn](rawParams, rawReturn, true) + case 12: + return parseGeneric[*v12Market.VerifyDealsForActivationParams, *v12Market.VerifyDealsForActivationReturn](rawParams, rawReturn, true) + case 11: + return parseGeneric[*v11Market.VerifyDealsForActivationParams, *v11Market.VerifyDealsForActivationReturn](rawParams, rawReturn, true) + case 10: + return parseGeneric[*v10Market.VerifyDealsForActivationParams, *v10Market.VerifyDealsForActivationReturn](rawParams, rawReturn, true) + case 9: + return parseGeneric[*v9Market.VerifyDealsForActivationParams, *v9Market.VerifyDealsForActivationReturn](rawParams, rawReturn, true) + case 8: + return parseGeneric[*v8Market.VerifyDealsForActivationParams, *v8Market.VerifyDealsForActivationReturn](rawParams, rawReturn, true) + } + return nil, fmt.Errorf("unsupported height: %d", height) +} + +func ActivateDealsParams(height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { + switch height { + case 15: + return parseGeneric[*v15Market.ActivateDealsParams, *v15Market.ActivateDealsResult](rawParams, rawReturn, true) + case 14: + return parseGeneric[*v14Market.ActivateDealsParams, *v14Market.ActivateDealsResult](rawParams, rawReturn, true) + case 13: + return parseGeneric[*v13Market.ActivateDealsParams, *v13Market.ActivateDealsResult](rawParams, rawReturn, true) + case 12: + return parseGeneric[*v12Market.ActivateDealsParams, *v12Market.ActivateDealsResult](rawParams, rawReturn, true) + case 11: + return parseGeneric[*v11Market.ActivateDealsParams, *v11Market.ActivateDealsResult](rawParams, rawReturn, true) + case 10: + return parseGeneric[*v10Market.ActivateDealsParams, *v10Market.ActivateDealsResult](rawParams, rawReturn, true) + case 9: + return parseGeneric[*v9Market.ActivateDealsParams, *v9Market.ActivateDealsResult](rawParams, rawReturn, true) + case 8: + // return parseGeneric[*v8Market.ActivateDealsParams, *v8Market.ActivateDealsResult](rawParams, rawReturn, true) + } + return nil, fmt.Errorf("unsupported height: %d", height) +} + +func OnMinerSectorsTerminateParams(height int64, rawParams []byte) (map[string]interface{}, error) { + switch height { + case 15: + return parseGeneric[*v15Market.OnMinerSectorsTerminateParams, *v15Market.OnMinerSectorsTerminateParams](rawParams, nil, false) + case 14: + return parseGeneric[*v14Market.OnMinerSectorsTerminateParams, *v14Market.OnMinerSectorsTerminateParams](rawParams, nil, false) + case 13: + return parseGeneric[*v13Market.OnMinerSectorsTerminateParams, *v13Market.OnMinerSectorsTerminateParams](rawParams, nil, false) + case 12: + return parseGeneric[*v12Market.OnMinerSectorsTerminateParams, *v12Market.OnMinerSectorsTerminateParams](rawParams, nil, false) + case 11: + return parseGeneric[*v11Market.OnMinerSectorsTerminateParams, *v11Market.OnMinerSectorsTerminateParams](rawParams, nil, false) + case 10: + return parseGeneric[*v10Market.OnMinerSectorsTerminateParams, *v10Market.OnMinerSectorsTerminateParams](rawParams, nil, false) + case 9: + return parseGeneric[*v9Market.OnMinerSectorsTerminateParams, *v9Market.OnMinerSectorsTerminateParams](rawParams, nil, false) + case 8: + return parseGeneric[*v8Market.OnMinerSectorsTerminateParams, *v8Market.OnMinerSectorsTerminateParams](rawParams, nil, false) + } + return nil, fmt.Errorf("unsupported height: %d", height) +} + +func ComputeDataCommitmentParams(height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { + switch height { + case 15: + // return parseGeneric[*v15Market.ComputeDataCommitmentParams, *v15Market.ComputeDataCommitmentReturn](rawParams, rawReturn, true) + case 14: + // return parseGeneric[*v14Market.ComputeDataCommitmentParams, *v14Market.ComputeDataCommitmentReturn](rawParams, rawReturn, true) + case 13: + // return parseGeneric[*v13Market.ComputeDataCommitmentParams, *v13Market.ComputeDataCommitmentReturn](rawParams, rawReturn, true) + case 12: + // return parseGeneric[*v12Market.ComputeDataCommitmentParams, *v12Market.ComputeDataCommitmentReturn](rawParams, rawReturn, true) + case 11: + return parseGeneric[*v11Market.ComputeDataCommitmentParams, *v11Market.ComputeDataCommitmentReturn](rawParams, rawReturn, true) + case 10: + return parseGeneric[*v10Market.ComputeDataCommitmentParams, *v10Market.ComputeDataCommitmentReturn](rawParams, rawReturn, true) + case 9: + return parseGeneric[*v9Market.ComputeDataCommitmentParams, *v9Market.ComputeDataCommitmentReturn](rawParams, rawReturn, true) + case 8: + return parseGeneric[*v8Market.ComputeDataCommitmentParams, *v8Market.ComputeDataCommitmentReturn](rawParams, rawReturn, true) + } + return nil, fmt.Errorf("unsupported height: %d", height) +} + +func GetBalanceParams(height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { + switch height { + case 15: + return parseGeneric[*address.Address, *v15Market.GetBalanceReturn](rawParams, rawReturn, true) + case 14: + return parseGeneric[*address.Address, *v14Market.GetBalanceReturn](rawParams, rawReturn, true) + case 13: + return parseGeneric[*address.Address, *v13Market.GetBalanceReturn](rawParams, rawReturn, true) + case 12: + return parseGeneric[*address.Address, *v12Market.GetBalanceReturn](rawParams, rawReturn, true) + case 11: + return parseGeneric[*address.Address, *v11Market.GetBalanceReturn](rawParams, rawReturn, true) + case 10: + return parseGeneric[*address.Address, *v10Market.GetBalanceReturn](rawParams, rawReturn, true) + case 9: + // return parseGeneric[*address.Address, *v9Market.GetBalanceReturn](rawParams, rawReturn, true) + case 8: + // return parseGeneric[*address.Address, *v8Market.GetBalanceReturn](rawParams, rawReturn, true) + } + return nil, fmt.Errorf("unsupported height: %d", height) +} + +func GetDealDataCommitmentParams(height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { + switch height { + case 15: + return parseGeneric[*v15Market.GetDealDataCommitmentParams, *v15Market.GetDealDataCommitmentReturn](rawParams, rawReturn, true) + case 14: + return parseGeneric[*v14Market.GetDealDataCommitmentParams, *v14Market.GetDealDataCommitmentReturn](rawParams, rawReturn, true) + case 13: + return parseGeneric[*v13Market.GetDealDataCommitmentParams, *v13Market.GetDealDataCommitmentReturn](rawParams, rawReturn, true) + case 12: + return parseGeneric[*v12Market.GetDealDataCommitmentParams, *v12Market.GetDealDataCommitmentReturn](rawParams, rawReturn, true) + case 11: + return parseGeneric[*v11Market.GetDealDataCommitmentParams, *v11Market.GetDealDataCommitmentReturn](rawParams, rawReturn, true) + case 10: + return parseGeneric[*v10Market.GetDealDataCommitmentParams, *v10Market.GetDealDataCommitmentReturn](rawParams, rawReturn, true) + case 9: + // return parseGeneric[*v9Market.GetDealDataCommitmentParams, *v9Market.GetDealDataCommitmentReturn](rawParams, rawReturn, true) + case 8: + // return parseGeneric[*v8Market.GetDealDataCommitmentParams, *v8Market.GetDealDataCommitmentReturn](rawParams, rawReturn, true) + } + return nil, fmt.Errorf("unsupported height: %d", height) +} + +func GetDealClientParams(height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { + switch height { + case 15: + return parseGeneric[*v15Market.GetDealClientParams, *v15Market.GetDealClientReturn](rawParams, rawReturn, true) + case 14: + return parseGeneric[*v14Market.GetDealClientParams, *v14Market.GetDealClientReturn](rawParams, rawReturn, true) + case 13: + return parseGeneric[*v13Market.GetDealClientParams, *v13Market.GetDealClientReturn](rawParams, rawReturn, true) + case 12: + return parseGeneric[*v12Market.GetDealClientParams, *v12Market.GetDealClientReturn](rawParams, rawReturn, true) + case 11: + return parseGeneric[*v11Market.GetDealClientParams, *v11Market.GetDealClientReturn](rawParams, rawReturn, true) + case 10: + return parseGeneric[*v10Market.GetDealClientParams, *v10Market.GetDealClientReturn](rawParams, rawReturn, true) + case 9: + // return parseGeneric[*v9Market.GetDealClientParams, *v9Market.GetDealClientReturn](rawParams, rawReturn, true) + case 8: + // return parseGeneric[*v8Market.GetDealClientParams, *v8Market.GetDealClientReturn](rawParams, rawReturn, true) + } + return nil, fmt.Errorf("unsupported height: %d", height) +} + +func GetDealProviderParams(height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { + switch height { + case 15: + return parseGeneric[*v15Market.GetDealProviderParams, *v15Market.GetDealProviderReturn](rawParams, rawReturn, true) + case 14: + return parseGeneric[*v14Market.GetDealProviderParams, *v14Market.GetDealProviderReturn](rawParams, rawReturn, true) + case 13: + return parseGeneric[*v13Market.GetDealProviderParams, *v13Market.GetDealProviderReturn](rawParams, rawReturn, true) + case 12: + return parseGeneric[*v12Market.GetDealProviderParams, *v12Market.GetDealProviderReturn](rawParams, rawReturn, true) + case 11: + return parseGeneric[*v11Market.GetDealProviderParams, *v11Market.GetDealProviderReturn](rawParams, rawReturn, true) + case 10: + return parseGeneric[*v10Market.GetDealProviderParams, *v10Market.GetDealProviderReturn](rawParams, rawReturn, true) + case 9: + // return parseGeneric[*v9Market.GetDealProviderParams, *v9Market.GetDealProviderReturn](rawParams, rawReturn, true) + case 8: + // return parseGeneric[*v8Market.GetDealProviderParams, *v8Market.GetDealProviderReturn](rawParams, rawReturn, true) + } + return nil, fmt.Errorf("unsupported height: %d", height) +} + +func GetDealLabelParams(height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { + switch height { + case 15: + return parseGeneric[*v15Market.GetDealLabelParams, *v15Market.GetDealLabelReturn](rawParams, rawReturn, true) + case 14: + return parseGeneric[*v14Market.GetDealLabelParams, *v14Market.GetDealLabelReturn](rawParams, rawReturn, true) + case 13: + return parseGeneric[*v13Market.GetDealLabelParams, *v13Market.GetDealLabelReturn](rawParams, rawReturn, true) + case 12: + return parseGeneric[*v12Market.GetDealLabelParams, *v12Market.GetDealLabelReturn](rawParams, rawReturn, true) + case 11: + return parseGeneric[*v11Market.GetDealLabelParams, *v11Market.GetDealLabelReturn](rawParams, rawReturn, true) + case 10: + return parseGeneric[*v10Market.GetDealLabelParams, *v10Market.GetDealLabelReturn](rawParams, rawReturn, true) + case 9: + // return parseGeneric[*v9Market.GetDealLabelParams, *v9Market.GetDealLabelReturn](rawParams, rawReturn, true) + case 8: + // return parseGeneric[*v8Market.GetDealLabelParams, *v8Market.GetDealLabelReturn](rawParams, rawReturn, true) + } + return nil, fmt.Errorf("unsupported height: %d", height) +} + +func GetDealTermParams(height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { + switch height { + case 15: + return parseGeneric[*v15Market.GetDealTermParams, *v15Market.GetDealTermReturn](rawParams, rawReturn, true) + case 14: + return parseGeneric[*v14Market.GetDealTermParams, *v14Market.GetDealTermReturn](rawParams, rawReturn, true) + case 13: + return parseGeneric[*v13Market.GetDealTermParams, *v13Market.GetDealTermReturn](rawParams, rawReturn, true) + case 12: + return parseGeneric[*v12Market.GetDealTermParams, *v12Market.GetDealTermReturn](rawParams, rawReturn, true) + case 11: + return parseGeneric[*v11Market.GetDealTermParams, *v11Market.GetDealTermReturn](rawParams, rawReturn, true) + case 10: + return parseGeneric[*v10Market.GetDealTermParams, *v10Market.GetDealTermReturn](rawParams, rawReturn, true) + case 9: + // return parseGeneric[*v9Market.GetDealTermParams, *v9Market.GetDealTermReturn](rawParams, rawReturn, true) + case 8: + // return parseGeneric[*v8Market.GetDealTermParams, *v8Market.GetDealTermReturn](rawParams, rawReturn, true) + } + return nil, fmt.Errorf("unsupported height: %d", height) +} + +func GetDealTotalPriceParams(height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { + switch height { + case 15: + return parseGeneric[*v15Market.GetDealTotalPriceParams, *v15Market.GetDealTotalPriceReturn](rawParams, rawReturn, true) + case 14: + return parseGeneric[*v14Market.GetDealTotalPriceParams, *v14Market.GetDealTotalPriceReturn](rawParams, rawReturn, true) + case 13: + return parseGeneric[*v13Market.GetDealTotalPriceParams, *v13Market.GetDealTotalPriceReturn](rawParams, rawReturn, true) + case 12: + return parseGeneric[*v12Market.GetDealTotalPriceParams, *v12Market.GetDealTotalPriceReturn](rawParams, rawReturn, true) + case 11: + return parseGeneric[*v11Market.GetDealTotalPriceParams, *v11Market.GetDealTotalPriceReturn](rawParams, rawReturn, true) + case 10: + return parseGeneric[*v10Market.GetDealTotalPriceParams, *v10Market.GetDealTotalPriceReturn](rawParams, rawReturn, true) + case 9: + // return parseGeneric[*v9Market.GetDealTotalPriceParams, *v9Market.GetDealTotalPriceReturn](rawParams, rawReturn, true) + case 8: + // return parseGeneric[*v8Market.GetDealTotalPriceParams, *v8Market.GetDealTotalPriceReturn](rawParams, rawReturn, true) + } + return nil, fmt.Errorf("unsupported height: %d", height) +} + +func GetDealClientCollateralParams(height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { + switch height { + case 15: + return parseGeneric[*v15Market.GetDealClientCollateralParams, *v15Market.GetDealClientCollateralReturn](rawParams, rawReturn, true) + case 14: + return parseGeneric[*v14Market.GetDealClientCollateralParams, *v14Market.GetDealClientCollateralReturn](rawParams, rawReturn, true) + case 13: + return parseGeneric[*v13Market.GetDealClientCollateralParams, *v13Market.GetDealClientCollateralReturn](rawParams, rawReturn, true) + case 12: + return parseGeneric[*v12Market.GetDealClientCollateralParams, *v12Market.GetDealClientCollateralReturn](rawParams, rawReturn, true) + case 11: + return parseGeneric[*v11Market.GetDealClientCollateralParams, *v11Market.GetDealClientCollateralReturn](rawParams, rawReturn, true) + case 10: + return parseGeneric[*v10Market.GetDealClientCollateralParams, *v10Market.GetDealClientCollateralReturn](rawParams, rawReturn, true) + case 9: + // return parseGeneric[*v9Market.GetDealClientCollateralParams, *v9Market.GetDealClientCollateralReturn](rawParams, rawReturn, true) + case 8: + // return parseGeneric[*v8Market.GetDealClientCollateralParams, *v8Market.GetDealClientCollateralReturn](rawParams, rawReturn, true) + } + return nil, fmt.Errorf("unsupported height: %d", height) +} + +func GetDealProviderCollateralParams(height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { + switch height { + case 15: + return parseGeneric[*v15Market.GetDealProviderCollateralParams, *v15Market.GetDealProviderCollateralReturn](rawParams, rawReturn, true) + case 14: + return parseGeneric[*v14Market.GetDealProviderCollateralParams, *v14Market.GetDealProviderCollateralReturn](rawParams, rawReturn, true) + case 13: + return parseGeneric[*v13Market.GetDealProviderCollateralParams, *v13Market.GetDealProviderCollateralReturn](rawParams, rawReturn, true) + case 12: + return parseGeneric[*v12Market.GetDealProviderCollateralParams, *v12Market.GetDealProviderCollateralReturn](rawParams, rawReturn, true) + case 11: + return parseGeneric[*v11Market.GetDealProviderCollateralParams, *v11Market.GetDealProviderCollateralReturn](rawParams, rawReturn, true) + case 10: + return parseGeneric[*v10Market.GetDealProviderCollateralParams, *v10Market.GetDealProviderCollateralReturn](rawParams, rawReturn, true) + case 9: + // return parseGeneric[*v9Market.GetDealProviderCollateralParams, *v9Market.GetDealProviderCollateralReturn](rawParams, rawReturn, true) + case 8: + // return parseGeneric[*v8Market.GetDealProviderCollateralParams, *v8Market.GetDealProviderCollateralReturn](rawParams, rawReturn, true) + } + return nil, fmt.Errorf("unsupported height: %d", height) +} + +func GetDealVerifiedParams(height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { + switch height { + case 15: + return parseGeneric[*v15Market.GetDealVerifiedParams, *v15Market.GetDealVerifiedReturn](rawParams, rawReturn, true) + case 14: + return parseGeneric[*v14Market.GetDealVerifiedParams, *v14Market.GetDealVerifiedReturn](rawParams, rawReturn, true) + case 13: + return parseGeneric[*v13Market.GetDealVerifiedParams, *v13Market.GetDealVerifiedReturn](rawParams, rawReturn, true) + case 12: + return parseGeneric[*v12Market.GetDealVerifiedParams, *v12Market.GetDealVerifiedReturn](rawParams, rawReturn, true) + case 11: + return parseGeneric[*v11Market.GetDealVerifiedParams, *v11Market.GetDealVerifiedReturn](rawParams, rawReturn, true) + case 10: + return parseGeneric[*v10Market.GetDealVerifiedParams, *v10Market.GetDealVerifiedReturn](rawParams, rawReturn, true) + case 9: + // return parseGeneric[*v9Market.GetDealVerifiedParams, *v9Market.GetDealVerifiedReturn](rawParams, rawReturn, true) + case 8: + // return parseGeneric[*v8Market.GetDealVerifiedParams, *v8Market.GetDealVerifiedReturn](rawParams, rawReturn, true) + } + return nil, fmt.Errorf("unsupported height: %d", height) +} + +func GetDealActivationParams(height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { + switch height { + case 15: + return parseGeneric[*v15Market.GetDealActivationParams, *v15Market.GetDealActivationReturn](rawParams, rawReturn, true) + case 14: + return parseGeneric[*v14Market.GetDealActivationParams, *v14Market.GetDealActivationReturn](rawParams, rawReturn, true) + case 13: + return parseGeneric[*v13Market.GetDealActivationParams, *v13Market.GetDealActivationReturn](rawParams, rawReturn, true) + case 12: + return parseGeneric[*v12Market.GetDealActivationParams, *v12Market.GetDealActivationReturn](rawParams, rawReturn, true) + case 11: + return parseGeneric[*v11Market.GetDealActivationParams, *v11Market.GetDealActivationReturn](rawParams, rawReturn, true) + case 10: + return parseGeneric[*v10Market.GetDealActivationParams, *v10Market.GetDealActivationReturn](rawParams, rawReturn, true) + case 9: + // return parseGeneric[*v9Market.GetDealActivationParams, *v9Market.GetDealActivationReturn](rawParams, rawReturn, true) + case 8: + // return parseGeneric[*v8Market.GetDealActivationParams, *v8Market.GetDealActivationReturn](rawParams, rawReturn, true) + } + return nil, fmt.Errorf("unsupported height: %d", height) +} diff --git a/actors/miner/address.go b/actors/miner/address.go new file mode 100644 index 00000000..e5dbb946 --- /dev/null +++ b/actors/miner/address.go @@ -0,0 +1,72 @@ +package miner + +import ( + "fmt" + + "github.com/filecoin-project/go-address" + miner15 "github.com/filecoin-project/go-state-types/builtin/v15/miner" +) + +func ChangeMultiaddrs(height int64, rawParams []byte) (map[string]interface{}, error) { + switch height { + case 15: + return parseGeneric[*miner15.ChangeMultiaddrsParams, *miner15.ChangeMultiaddrsParams](rawParams, nil, false) + } + return nil, fmt.Errorf("unsupported height: %d", height) +} + +func ChangePeerID(height int64, rawParams []byte) (map[string]interface{}, error) { + switch height { + case 15: + return parseGeneric[*miner15.ChangePeerIDParams, *miner15.ChangePeerIDParams](rawParams, nil, false) + } + return nil, fmt.Errorf("unsupported height: %d", height) +} + +func ChangeWorkerAddress(height int64, rawParams []byte) (map[string]interface{}, error) { + switch height { + case 15: + return parseGeneric[*miner15.ChangeWorkerAddressParams, *miner15.ChangeWorkerAddressParams](rawParams, nil, false) + } + return nil, fmt.Errorf("unsupported height: %d", height) +} + +func ChangeOwnerAddress(height int64, rawParams []byte) (map[string]interface{}, error) { + switch height { + case 15: + return parseGeneric[*address.Address, *address.Address](rawParams, nil, false) + } + return nil, fmt.Errorf("unsupported height: %d", height) +} + +func IsControllingAddressExported(height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { + switch height { + case 15: + return parseGeneric[*miner15.IsControllingAddressParams, *miner15.IsControllingAddressReturn](rawParams, rawReturn, true) + } + return nil, fmt.Errorf("unsupported height: %d", height) +} + +func GetOwner(height int64, rawReturn []byte) (map[string]interface{}, error) { + switch height { + case 15: + return parseGeneric[*miner15.GetOwnerReturn, *miner15.GetOwnerReturn](rawReturn, nil, false) + } + return nil, fmt.Errorf("unsupported height: %d", height) +} + +func GetPeerID(height int64, rawReturn []byte) (map[string]interface{}, error) { + switch height { + case 15: + return parseGeneric[*miner15.GetPeerIDReturn, *miner15.GetPeerIDReturn](rawReturn, nil, false) + } + return nil, fmt.Errorf("unsupported height: %d", height) +} + +func GetMultiaddrs(height int64, rawReturn []byte) (map[string]interface{}, error) { + switch height { + case 15: + return parseGeneric[*miner15.GetMultiAddrsReturn, *miner15.GetMultiAddrsReturn](rawReturn, nil, false) + } + return nil, fmt.Errorf("unsupported height: %d", height) +} diff --git a/actors/miner/balance.go b/actors/miner/balance.go new file mode 100644 index 00000000..75d3b282 --- /dev/null +++ b/actors/miner/balance.go @@ -0,0 +1,31 @@ +package miner + +import ( + "fmt" + + miner15 "github.com/filecoin-project/go-state-types/builtin/v15/miner" +) + +func GetAvailableBalance(height int64, rawReturn []byte) (map[string]interface{}, error) { + switch height { + case 15: + return parseGeneric[*miner15.GetAvailableBalanceReturn, *miner15.GetAvailableBalanceReturn](rawReturn, nil, false) + } + return nil, fmt.Errorf("unsupported height: %d", height) +} + +func GetVestingFunds(height int64, rawReturn []byte) (map[string]interface{}, error) { + switch height { + case 15: + return parseGeneric[*miner15.GetVestingFundsReturn, *miner15.GetVestingFundsReturn](rawReturn, nil, false) + } + return nil, fmt.Errorf("unsupported height: %d", height) +} + +func ParseWithdrawBalance(height int64, rawParams []byte) (map[string]interface{}, error) { + switch height { + case 15: + return parseGeneric[*miner15.WithdrawBalanceParams, *miner15.WithdrawBalanceParams](rawParams, nil, false) + } + return nil, fmt.Errorf("unsupported height: %d", height) +} diff --git a/actors/miner/miner.go b/actors/miner/miner.go new file mode 100644 index 00000000..e2ae3307 --- /dev/null +++ b/actors/miner/miner.go @@ -0,0 +1,235 @@ +package miner + +import ( + "bytes" + "fmt" + "io" + + miner10 "github.com/filecoin-project/go-state-types/builtin/v10/miner" + miner11 "github.com/filecoin-project/go-state-types/builtin/v11/miner" + miner12 "github.com/filecoin-project/go-state-types/builtin/v12/miner" + miner13 "github.com/filecoin-project/go-state-types/builtin/v13/miner" + miner14 "github.com/filecoin-project/go-state-types/builtin/v14/miner" + miner15 "github.com/filecoin-project/go-state-types/builtin/v15/miner" + miner8 "github.com/filecoin-project/go-state-types/builtin/v8/miner" + miner9 "github.com/filecoin-project/go-state-types/builtin/v9/miner" + "github.com/zondax/fil-parser/parser" +) + +type minerParam interface { + UnmarshalCBOR(io.Reader) error +} + +type minerReturn interface { + UnmarshalCBOR(io.Reader) error +} + +func parseGeneric[T minerParam, R minerReturn](rawParams, rawReturn []byte, customReturn bool) (map[string]interface{}, error) { + metadata := make(map[string]interface{}) + reader := bytes.NewReader(rawParams) + var params T + err := params.UnmarshalCBOR(reader) + if err != nil { + return metadata, err + } + metadata[parser.ParamsKey] = params + if !customReturn { + return metadata, nil + } + reader = bytes.NewReader(rawReturn) + var r R + err = r.UnmarshalCBOR(reader) + if err != nil { + return metadata, err + } + metadata[parser.ReturnKey] = r + return metadata, nil +} + +func TerminateSectors(height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { + switch height { + case 15: + return parseGeneric[*miner15.TerminateSectorsParams, *miner15.TerminateSectorsReturn](rawParams, rawReturn, true) + case 14: + return parseGeneric[*miner14.TerminateSectorsParams, *miner14.TerminateSectorsReturn](rawParams, rawReturn, true) + case 13: + return parseGeneric[*miner13.TerminateSectorsParams, *miner13.TerminateSectorsReturn](rawParams, rawReturn, true) + case 12: + return parseGeneric[*miner12.TerminateSectorsParams, *miner12.TerminateSectorsReturn](rawParams, rawReturn, true) + case 11: + return parseGeneric[*miner11.TerminateSectorsParams, *miner11.TerminateSectorsReturn](rawParams, rawReturn, true) + case 10: + return parseGeneric[*miner10.TerminateSectorsParams, *miner10.TerminateSectorsReturn](rawParams, rawReturn, true) + case 9: + return parseGeneric[*miner9.TerminateSectorsParams, *miner9.TerminateSectorsReturn](rawParams, rawReturn, true) + case 8: + return parseGeneric[*miner8.TerminateSectorsParams, *miner8.TerminateSectorsReturn](rawParams, rawReturn, true) + } + return nil, fmt.Errorf("unsupported height: %d", height) +} + +func DeclareFaults(height int64, rawParams []byte) (map[string]interface{}, error) { + switch height { + case 15: + return parseGeneric[*miner15.DeclareFaultsParams, *miner15.DeclareFaultsParams](rawParams, nil, false) + case 14: + return parseGeneric[*miner14.DeclareFaultsParams, *miner14.DeclareFaultsParams](rawParams, nil, false) + case 13: + return parseGeneric[*miner13.DeclareFaultsParams, *miner13.DeclareFaultsParams](rawParams, nil, false) + case 12: + return parseGeneric[*miner12.DeclareFaultsParams, *miner12.DeclareFaultsParams](rawParams, nil, false) + case 11: + return parseGeneric[*miner11.DeclareFaultsParams, *miner11.DeclareFaultsParams](rawParams, nil, false) + case 10: + return parseGeneric[*miner10.DeclareFaultsParams, *miner10.DeclareFaultsParams](rawParams, nil, false) + case 9: + return parseGeneric[*miner9.DeclareFaultsParams, *miner9.DeclareFaultsParams](rawParams, nil, false) + case 8: + return parseGeneric[*miner8.DeclareFaultsParams, *miner8.DeclareFaultsParams](rawParams, nil, false) + } + return nil, fmt.Errorf("unsupported height: %d", height) +} + +func DeclareFaultsRecovered(height int64, rawParams []byte) (map[string]interface{}, error) { + switch height { + case 15: + return parseGeneric[*miner15.DeclareFaultsRecoveredParams, *miner15.DeclareFaultsRecoveredParams](rawParams, nil, false) + case 14: + return parseGeneric[*miner14.DeclareFaultsRecoveredParams, *miner14.DeclareFaultsRecoveredParams](rawParams, nil, false) + case 13: + return parseGeneric[*miner13.DeclareFaultsRecoveredParams, *miner13.DeclareFaultsRecoveredParams](rawParams, nil, false) + case 12: + return parseGeneric[*miner12.DeclareFaultsRecoveredParams, *miner12.DeclareFaultsRecoveredParams](rawParams, nil, false) + case 11: + return parseGeneric[*miner11.DeclareFaultsRecoveredParams, *miner11.DeclareFaultsRecoveredParams](rawParams, nil, false) + case 10: + return parseGeneric[*miner10.DeclareFaultsRecoveredParams, *miner10.DeclareFaultsRecoveredParams](rawParams, nil, false) + case 9: + return parseGeneric[*miner9.DeclareFaultsRecoveredParams, *miner9.DeclareFaultsRecoveredParams](rawParams, nil, false) + case 8: + return parseGeneric[*miner8.DeclareFaultsRecoveredParams, *miner8.DeclareFaultsRecoveredParams](rawParams, nil, false) + } + return nil, fmt.Errorf("unsupported height: %d", height) +} + +func ProveReplicaUpdates(height int64, rawParams []byte) (map[string]interface{}, error) { + switch height { + case 15: + return parseGeneric[*miner15.ProveReplicaUpdatesParams, *miner15.ProveReplicaUpdatesParams](rawParams, nil, false) + case 14: + return parseGeneric[*miner14.ProveReplicaUpdatesParams, *miner14.ProveReplicaUpdatesParams](rawParams, nil, false) + case 13: + return parseGeneric[*miner13.ProveReplicaUpdatesParams, *miner13.ProveReplicaUpdatesParams](rawParams, nil, false) + case 12: + return parseGeneric[*miner12.ProveReplicaUpdatesParams, *miner12.ProveReplicaUpdatesParams](rawParams, nil, false) + case 11: + return parseGeneric[*miner11.ProveReplicaUpdatesParams, *miner11.ProveReplicaUpdatesParams](rawParams, nil, false) + case 10: + return parseGeneric[*miner10.ProveReplicaUpdatesParams, *miner10.ProveReplicaUpdatesParams](rawParams, nil, false) + case 9: + return parseGeneric[*miner9.ProveReplicaUpdatesParams, *miner9.ProveReplicaUpdatesParams](rawParams, nil, false) + case 8: + return parseGeneric[*miner8.ProveReplicaUpdatesParams, *miner8.ProveReplicaUpdatesParams](rawParams, nil, false) + } + return nil, fmt.Errorf("unsupported height: %d", height) +} + +func PreCommitSectorBatch2(height int64, rawParams []byte) (map[string]interface{}, error) { + switch height { + case 15: + return parseGeneric[*miner15.PreCommitSectorBatchParams2, *miner15.PreCommitSectorBatchParams2](rawParams, nil, false) + case 14: + return parseGeneric[*miner14.PreCommitSectorBatchParams2, *miner14.PreCommitSectorBatchParams2](rawParams, nil, false) + case 13: + return parseGeneric[*miner13.PreCommitSectorBatchParams2, *miner13.PreCommitSectorBatchParams2](rawParams, nil, false) + case 12: + return parseGeneric[*miner12.PreCommitSectorBatchParams2, *miner12.PreCommitSectorBatchParams2](rawParams, nil, false) + case 11: + return parseGeneric[*miner11.PreCommitSectorBatchParams2, *miner11.PreCommitSectorBatchParams2](rawParams, nil, false) + case 10: + return parseGeneric[*miner10.PreCommitSectorBatchParams2, *miner10.PreCommitSectorBatchParams2](rawParams, nil, false) + case 9: + return parseGeneric[*miner9.PreCommitSectorBatchParams2, *miner9.PreCommitSectorBatchParams2](rawParams, nil, false) + case 8: + // return parseGeneric[*miner8.PreCommitSectorBatchParams2, *miner8.PreCommitSectorBatchParams2](rawParams, nil, false) + } + return nil, fmt.Errorf("unsupported height: %d", height) +} + +func ProveReplicaUpdates2(height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { + switch height { + case 15: + return parseGeneric[*miner15.ProveReplicaUpdatesParams2, *miner15.ProveReplicaUpdatesParams2](rawParams, rawReturn, true) + case 14: + return parseGeneric[*miner14.ProveReplicaUpdatesParams2, *miner14.ProveReplicaUpdatesParams2](rawParams, rawReturn, true) + case 13: + return parseGeneric[*miner13.ProveReplicaUpdatesParams2, *miner13.ProveReplicaUpdatesParams2](rawParams, rawReturn, true) + case 12: + return parseGeneric[*miner12.ProveReplicaUpdatesParams2, *miner12.ProveReplicaUpdatesParams2](rawParams, rawReturn, true) + case 11: + return parseGeneric[*miner11.ProveReplicaUpdatesParams2, *miner11.ProveReplicaUpdatesParams2](rawParams, rawReturn, true) + case 10: + return parseGeneric[*miner10.ProveReplicaUpdatesParams2, *miner10.ProveReplicaUpdatesParams2](rawParams, rawReturn, true) + case 9: + return parseGeneric[*miner9.ProveReplicaUpdatesParams2, *miner9.ProveReplicaUpdatesParams2](rawParams, rawReturn, true) + case 8: + // return parseGeneric[*miner8.ProveReplicaUpdatesParams2, *miner8.ProveReplicaUpdatesParams2](rawParams, rawReturn, true) + } + return nil, fmt.Errorf("unsupported height: %d", height) +} + +func ProveCommitAggregate(height int64, rawParams []byte) (map[string]interface{}, error) { + switch height { + case 15: + return parseGeneric[*miner15.ProveCommitAggregateParams, *miner15.ProveCommitAggregateParams](rawParams, nil, false) + } + return nil, fmt.Errorf("unsupported height: %d", height) +} + +func DisputeWindowedPoSt(height int64, rawParams []byte) (map[string]interface{}, error) { + switch height { + case 15: + return parseGeneric[*miner15.DisputeWindowedPoStParams, *miner15.DisputeWindowedPoStParams](rawParams, nil, false) + } + return nil, fmt.Errorf("unsupported height: %d", height) +} + +func ReportConsensusFault(height int64, rawParams []byte) (map[string]interface{}, error) { + switch height { + case 15: + return parseGeneric[*miner15.ReportConsensusFaultParams, *miner15.ReportConsensusFaultParams](rawParams, nil, false) + } + return nil, fmt.Errorf("unsupported height: %d", height) +} + +func ChangeBeneficiary(height int64, rawParams []byte) (map[string]interface{}, error) { + switch height { + case 15: + return parseGeneric[*miner15.ChangeBeneficiaryParams, *miner15.ChangeBeneficiaryParams](rawParams, nil, false) + } + return nil, fmt.Errorf("unsupported height: %d", height) +} + +func MinerConstructor(height int64, rawParams []byte) (map[string]interface{}, error) { + switch height { + case 15: + return parseGeneric[*miner15.MinerConstructorParams, *miner15.MinerConstructorParams](rawParams, nil, false) + } + return nil, fmt.Errorf("unsupported height: %d", height) +} + +func ApplyRewards(height int64, rawParams []byte) (map[string]interface{}, error) { + switch height { + case 15: + return parseGeneric[*miner15.ApplyRewardParams, *miner15.ApplyRewardParams](rawParams, nil, false) + } + return nil, fmt.Errorf("unsupported height: %d", height) +} + +func OnDeferredCronEvent(height int64, rawParams []byte) (map[string]interface{}, error) { + switch height { + case 15: + return parseGeneric[*miner15.DeferredCronEventParams, *miner15.DeferredCronEventParams](rawParams, nil, false) + } + return nil, fmt.Errorf("unsupported height: %d", height) +} diff --git a/actors/miner/sector.go b/actors/miner/sector.go new file mode 100644 index 00000000..dce89d52 --- /dev/null +++ b/actors/miner/sector.go @@ -0,0 +1,103 @@ +package miner + +import ( + "fmt" + + miner15 "github.com/filecoin-project/go-state-types/builtin/v15/miner" +) + +func ExtendSectorExpiration2(height int64, rawParams []byte) (map[string]interface{}, error) { + switch height { + case 15: + return parseGeneric[*miner15.ExtendSectorExpiration2Params, *miner15.ExtendSectorExpiration2Params](rawParams, nil, false) + } + return nil, fmt.Errorf("unsupported height: %d", height) +} + +func PreCommitSector(height int64, rawParams []byte) (map[string]interface{}, error) { + switch height { + case 15: + return parseGeneric[*miner15.PreCommitSectorParams, *miner15.PreCommitSectorParams](rawParams, nil, false) + } + return nil, fmt.Errorf("unsupported height: %d", height) +} + +func ProveCommitSector(height int64, rawParams []byte) (map[string]interface{}, error) { + switch height { + case 15: + return parseGeneric[*miner15.ProveCommitSectorParams, *miner15.ProveCommitSectorParams](rawParams, nil, false) + } + return nil, fmt.Errorf("unsupported height: %d", height) +} + +func ProveCommitSectors3(height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { + switch height { + case 15: + return parseGeneric[*miner15.ProveCommitSectors3Params, *miner15.ProveCommitSectors3Return](rawParams, rawReturn, true) + } + return nil, fmt.Errorf("unsupported height: %d", height) +} + +func SubmitWindowedPoSt(height int64, rawParams []byte) (map[string]interface{}, error) { + switch height { + case 15: + return parseGeneric[*miner15.SubmitWindowedPoStParams, *miner15.SubmitWindowedPoStParams](rawParams, nil, false) + } + return nil, fmt.Errorf("unsupported height: %d", height) +} + +func ConfirmSectorProofsValid(height int64, rawParams []byte) (map[string]interface{}, error) { + switch height { + case 15: + return parseGeneric[*miner15.ConfirmSectorProofsParams, *miner15.ConfirmSectorProofsParams](rawParams, nil, false) + } + return nil, fmt.Errorf("unsupported height: %d", height) +} + +func CheckSectorProven(height int64, rawParams []byte) (map[string]interface{}, error) { + switch height { + case 15: + return parseGeneric[*miner15.CheckSectorProvenParams, *miner15.CheckSectorProvenParams](rawParams, nil, false) + } + return nil, fmt.Errorf("unsupported height: %d", height) +} + +func ExtendSectorExpiration(height int64, rawParams []byte) (map[string]interface{}, error) { + switch height { + case 15: + return parseGeneric[*miner15.ExtendSectorExpirationParams, *miner15.ExtendSectorExpirationParams](rawParams, nil, false) + } + return nil, fmt.Errorf("unsupported height: %d", height) +} + +func CompactSectorNumbers(height int64, rawParams []byte) (map[string]interface{}, error) { + switch height { + case 15: + return parseGeneric[*miner15.CompactSectorNumbersParams, *miner15.CompactSectorNumbersParams](rawParams, nil, false) + } + return nil, fmt.Errorf("unsupported height: %d", height) +} + +func CompactPartitions(height int64, rawParams []byte) (map[string]interface{}, error) { + switch height { + case 15: + return parseGeneric[*miner15.CompactPartitionsParams, *miner15.CompactPartitionsParams](rawParams, nil, false) + } + return nil, fmt.Errorf("unsupported height: %d", height) +} + +func PreCommitSectorBatch(height int64, rawParams []byte) (map[string]interface{}, error) { + switch height { + case 15: + return parseGeneric[*miner15.PreCommitSectorBatchParams, *miner15.PreCommitSectorBatchParams](rawParams, nil, false) + } + return nil, fmt.Errorf("unsupported height: %d", height) +} + +func GetSectorSize(height int64, rawReturn []byte) (map[string]interface{}, error) { + switch height { + case 15: + return parseGeneric[*miner15.GetSectorSizeReturn, *miner15.GetSectorSizeReturn](rawReturn, nil, false) + } + return nil, fmt.Errorf("unsupported height: %d", height) +} diff --git a/actors/multisig/multisig.go b/actors/multisig/multisig.go new file mode 100644 index 00000000..8bb37f2e --- /dev/null +++ b/actors/multisig/multisig.go @@ -0,0 +1,142 @@ +package multisig + +import ( + "bytes" + "io" + + filTypes "github.com/filecoin-project/lotus/chain/types" + + "github.com/filecoin-project/go-state-types/abi" + multisig10 "github.com/filecoin-project/go-state-types/builtin/v10/multisig" + multisig11 "github.com/filecoin-project/go-state-types/builtin/v11/multisig" + multisig12 "github.com/filecoin-project/go-state-types/builtin/v12/multisig" + multisig13 "github.com/filecoin-project/go-state-types/builtin/v13/multisig" + multisig14 "github.com/filecoin-project/go-state-types/builtin/v14/multisig" + multisig15 "github.com/filecoin-project/go-state-types/builtin/v15/multisig" + multisig8 "github.com/filecoin-project/go-state-types/builtin/v8/multisig" + multisig9 "github.com/filecoin-project/go-state-types/builtin/v9/multisig" + + "github.com/zondax/fil-parser/parser" +) + +func parseWithMsigParser[T multisigParams, R multisigReturn](msg *parser.LotusMessage, + height int64, + key filTypes.TipSetKey, + fn parseFn, + rawReturn []byte, + unmarshaller func(io.Reader, any) error, + customReturn bool, +) (map[string]interface{}, error) { + + metadata := make(map[string]interface{}) + params, err := fn(msg, height, key) + if err != nil { + return map[string]interface{}{}, err + } + metadata[parser.ParamsKey] = params + + if customReturn { + var r R + err = unmarshaller(bytes.NewReader(rawReturn), &r) + if err != nil { + return map[string]interface{}{}, err + } + metadata[parser.ReturnKey] = r + } + return metadata, nil + +} + +func parse[T multisigParams, P []byte | string](raw P, unmarshaller func(io.Reader, any) error) (map[string]interface{}, error) { + metadata := make(map[string]interface{}) + var params T + rawBytes, err := toBytes(raw) + if err != nil { + return map[string]interface{}{}, err + } + reader := bytes.NewReader(rawBytes) + err = unmarshaller(reader, ¶ms) + if err != nil { + return map[string]interface{}{}, err + } + metadata[parser.ParamsKey] = params + return metadata, nil +} + +func MsigConstructor(height int64, raw []byte) (map[string]interface{}, error) { + switch height { + case 8: + return parse[*multisig8.ConstructorParams, []byte](raw, cborUnmarshaller[*multisig8.ConstructorParams]) + case 9: + return parse[*multisig9.ConstructorParams, []byte](raw, cborUnmarshaller[*multisig9.ConstructorParams]) + case 10: + return parse[*multisig10.ConstructorParams, []byte](raw, cborUnmarshaller[*multisig10.ConstructorParams]) + case 11: + return parse[*multisig11.ConstructorParams, []byte](raw, cborUnmarshaller[*multisig11.ConstructorParams]) + case 12: + return parse[*multisig12.ConstructorParams, []byte](raw, cborUnmarshaller[*multisig12.ConstructorParams]) + case 13: + return parse[*multisig13.ConstructorParams, []byte](raw, cborUnmarshaller[*multisig13.ConstructorParams]) + case 14: + return parse[*multisig14.ConstructorParams, []byte](raw, cborUnmarshaller[*multisig14.ConstructorParams]) + case 15: + return parse[*multisig15.ConstructorParams, []byte](raw, cborUnmarshaller[*multisig15.ConstructorParams]) + } + return map[string]interface{}{}, nil +} + +func MsigParams(msg *parser.LotusMessage, height int64, key filTypes.TipSetKey, parser parseFn) (map[string]interface{}, error) { + switch height { + case 8: + return parseWithMsigParser[*multisig8.ConstructorParams, *multisig8.ConstructorParams](msg, height, key, parser, nil, jsonUnmarshaller[*multisig8.ConstructorParams], false) + } + return map[string]interface{}{}, nil +} + +func Approve(msg *parser.LotusMessage, height int64, key filTypes.TipSetKey, rawReturn []byte, parser parseFn) (map[string]interface{}, error) { + switch height { + case 8: + return parseWithMsigParser[*multisig8.ApproveReturn, *multisig8.ApproveReturn](msg, height, key, parser, rawReturn, cborUnmarshaller[*multisig8.ApproveReturn], true) + } + return map[string]interface{}{}, nil +} + +func Cancel(msg *parser.LotusMessage, height int64, key filTypes.TipSetKey, rawReturn []byte, parser parseFn) (map[string]interface{}, error) { + switch height { + case 8: + return parseWithMsigParser[metadataWithCbor, metadataWithCbor](msg, height, key, parser, rawReturn, noopUnmarshaller[metadataWithCbor], false) + } + return map[string]interface{}{}, nil +} + +func RemoveSigner(msg *parser.LotusMessage, height int64, key filTypes.TipSetKey, rawReturn []byte, parser parseFn) (map[string]interface{}, error) { + switch height { + case 8: + return parseWithMsigParser[metadataWithCbor, metadataWithCbor](msg, height, key, parser, rawReturn, noopUnmarshaller[metadataWithCbor], false) + } + return map[string]interface{}{}, nil +} + +func ChangeNumApprovalsThreshold(msg *parser.LotusMessage, height int64, key filTypes.TipSetKey, rawReturn []byte, parser parseFn) (map[string]interface{}, error) { + switch height { + case 8: + return parse[*multisig8.ChangeNumApprovalsThresholdParams, []byte](rawReturn, cborUnmarshaller[*multisig8.ChangeNumApprovalsThresholdParams]) + } + return map[string]interface{}{}, nil +} + +func LockBalance(msg *parser.LotusMessage, height int64, key filTypes.TipSetKey, rawReturn []byte, parser parseFn) (map[string]interface{}, error) { + switch height { + case 8: + return parse[*multisig8.LockBalanceParams, []byte](rawReturn, cborUnmarshaller[*multisig8.LockBalanceParams]) + } + return map[string]interface{}{}, nil +} + +func UniversalReceiverHook(msg *parser.LotusMessage, height int64, key filTypes.TipSetKey, rawReturn []byte, parser parseFn) (map[string]interface{}, error) { + switch height { + case 8: + return parse[*abi.CborBytesTransparent, []byte](rawReturn, cborUnmarshaller[*abi.CborBytesTransparent]) + } + return map[string]interface{}{}, nil +} diff --git a/actors/multisig/types.go b/actors/multisig/types.go new file mode 100644 index 00000000..9c9c5e70 --- /dev/null +++ b/actors/multisig/types.go @@ -0,0 +1,81 @@ +package multisig + +import ( + "encoding/json" + "io" +) + +type WithCBOR struct { +} + +func (w *WithCBOR) UnmarshalCBOR(reader io.Reader) error { + return nil +} + +func (w *WithCBOR) MarshalCBOR(writer io.Writer) error { + return nil +} + +type ChangeOwnerAddressParams struct { + WithCBOR + Params string `json:"Params"` +} + +// I decided omit ethLog because it's not needed +type InvokeContractParams struct { + WithCBOR + Params string `json:"Params"` + Return string `json:"Return"` +} + +type ApproveValue struct { + ID int `json:"ID"` + ProposalHash string `json:"ProposalHash"` + Return any `json:"Return"` +} + +type CancelValue struct { + WithCBOR + ID int `json:"ID"` + ProposalHash string `json:"ProposalHash"` +} + +func mapToStruct(m map[string]interface{}, v interface{}) error { + data, err := json.Marshal(m) + if err != nil { + return err + } + return json.Unmarshal(data, v) +} + +type SendValue struct { + WithCBOR + Params interface{} `json:"Params"` +} + +type UniversalReceiverHookValue struct { + Type uint64 `json:"Type"` + Payload string `json:"Payload"` + Return UniversalReceiverHookReturnValue `json:"Return"` +} + +type UniversalReceiverHookParams struct { + Type_ int `json:"Type_"` + Payload string `json:"Payload"` +} + +type TransactionUniversalReceiverHookMetadata struct { + Params string `json:"Params"` + Return UniversalReceiverHookReturnValue `json:"Return"` +} + +type UniversalReceiverHookReturnValue struct { + AllocationResults UniversalReceiverHookResults `json:"AllocationResults"` + ExtensionResults UniversalReceiverHookResults `json:"ExtensionResults"` + NewAllocations []int `json:"NewAllocations"` +} + +type UniversalReceiverHookResults struct { + SuccessCount int `json:"SuccessCount"` + FailCodes interface{} `json:"FailCodes"` +} diff --git a/actors/multisig/utils.go b/actors/multisig/utils.go new file mode 100644 index 00000000..eae95af4 --- /dev/null +++ b/actors/multisig/utils.go @@ -0,0 +1,67 @@ +package multisig + +import ( + "encoding/json" + "errors" + "fmt" + "io" + + filTypes "github.com/filecoin-project/lotus/chain/types" + "github.com/zondax/fil-parser/parser" +) + +type multisigParams interface { + UnmarshalCBOR(io.Reader) error +} + +type multisigReturn interface { + UnmarshalCBOR(io.Reader) error +} + +type parseFn func(*parser.LotusMessage, int64, filTypes.TipSetKey) (string, error) + +type metadataWithCbor map[string]interface{} + +func (m metadataWithCbor) UnmarshalCBOR(reader io.Reader) error { + return nil +} + +func jsonUnmarshaller[T multisigParams](reader io.Reader, to any) error { + err := json.NewDecoder(reader).Decode(to) + if err != nil { + return err + } + return nil +} + +func cborUnmarshaller[T multisigParams](reader io.Reader, to any) error { + return to.(T).UnmarshalCBOR(reader) +} + +func noopUnmarshaller[T multisigParams](reader io.Reader, to any) error { + return nil +} + +func toBytes(raw any) ([]byte, error) { + switch v := raw.(type) { + case []byte: + return v, nil + case string: + return []byte(v), nil + } + return nil, errors.New("invalid type") +} + +func getValue[T multisigParams](height int64, raw map[string]interface{}) (interface{}, error) { + paramsRaw, ok := raw["Params"].(map[string]interface{}) + if !ok { + return nil, fmt.Errorf("Params not found or not a map[string]interface{}") + } + + var v T + err := mapToStruct(paramsRaw, &v) + if err != nil { + return nil, err + } + return v, nil +} diff --git a/actors/multisig/values.go b/actors/multisig/values.go new file mode 100644 index 00000000..cfdf9547 --- /dev/null +++ b/actors/multisig/values.go @@ -0,0 +1,228 @@ +package multisig + +import ( + "encoding/json" + "fmt" + + miner11 "github.com/filecoin-project/go-state-types/builtin/v11/miner" + multisig11 "github.com/filecoin-project/go-state-types/builtin/v11/multisig" + "github.com/filecoin-project/go-state-types/exitcode" +) + +func ChangeOwnerAddressValue(height int64, txMetadata string) (interface{}, error) { + switch height { + case 11: + return parse[*ChangeOwnerAddressParams, string](txMetadata, jsonUnmarshaller[*ChangeOwnerAddressParams]) + } + return nil, nil +} + +func ParseWithdrawBalanceValue(height int64, txMetadata string) (interface{}, error) { + switch height { + case 11: + return parse[*miner11.WithdrawBalanceParams, string](txMetadata, jsonUnmarshaller[*miner11.WithdrawBalanceParams]) + } + return nil, nil +} + +func ParseInvokeContractValue(height int64, txMetadata string) (interface{}, error) { + switch height { + case 11: + return parse[*InvokeContractParams, string](txMetadata, jsonUnmarshaller[*InvokeContractParams]) + } + return nil, nil +} + +func ParseAddSignerValue(height int64, txMetadata string) (interface{}, error) { + switch height { + case 11: + return parse[*multisig11.AddSignerParams, string](txMetadata, jsonUnmarshaller[*multisig11.AddSignerParams]) + } + return nil, nil +} + +func ParseApproveValue(height int64, txMetadata string) (interface{}, error) { + switch height { + case 11: + if data, err := parse[metadataWithCbor, string](txMetadata, jsonUnmarshaller[metadataWithCbor]); err != nil { + return nil, err + } else { + return getApproveReturn(height, data) + } + } + return nil, nil +} + +func ParseCancelValue(height int64, txMetadata string) (interface{}, error) { + switch height { + case 11: + if data, err := parse[metadataWithCbor, string](txMetadata, jsonUnmarshaller[metadataWithCbor]); err != nil { + return nil, err + } else { + return getCancelReturn(height, data) + } + } + return nil, nil +} + +func ChangeNumApprovalsThresholdValue(height int64, txMetadata string) (interface{}, error) { + switch height { + case 11: + return parse[*multisig11.ChangeNumApprovalsThresholdParams, string](txMetadata, jsonUnmarshaller[*multisig11.ChangeNumApprovalsThresholdParams]) + } + return nil, nil +} + +func ParseConstructorValue(height int64, txMetadata string) (interface{}, error) { + switch height { + case 11: + if data, err := parse[*multisig11.ConstructorParams, string](txMetadata, jsonUnmarshaller[*multisig11.ConstructorParams]); err != nil { + return nil, err + } else { + return getValue[*multisig11.ConstructorParams](height, data) + } + } + return nil, nil +} + +func ParseLockBalanceValue(height int64, txMetadata string) (interface{}, error) { + switch height { + case 11: + if data, err := parse[*multisig11.LockBalanceParams, string](txMetadata, jsonUnmarshaller[*multisig11.LockBalanceParams]); err != nil { + return nil, err + } else { + return getValue[*multisig11.LockBalanceParams](height, data) + } + } + return nil, nil +} + +func ParseRemoveSignerValue(height int64, txMetadata string) (interface{}, error) { + switch height { + case 11: + if data, err := parse[*multisig11.RemoveSignerParams, string](txMetadata, jsonUnmarshaller[*multisig11.RemoveSignerParams]); err != nil { + return nil, err + } else { + return getValue[*multisig11.RemoveSignerParams](height, data) + } + } + return nil, nil +} + +func ParseSendValue(height int64, txMetadata string) (interface{}, error) { + switch height { + case 11: + return parse[*SendValue, string](txMetadata, jsonUnmarshaller[*SendValue]) + } + return nil, nil +} + +func ParseSwapSignerValue(height int64, txMetadata string) (interface{}, error) { + switch height { + case 11: + return parse[*multisig11.SwapSignerParams, string](txMetadata, jsonUnmarshaller[*multisig11.SwapSignerParams]) + } + return nil, nil +} + +func ParseUniversalReceiverHookValue(height int64, txMetadata string) (interface{}, error) { + var tx TransactionUniversalReceiverHookMetadata + err := json.Unmarshal([]byte(txMetadata), &tx) + if err != nil { + return nil, err + } + + var params UniversalReceiverHookParams + err = json.Unmarshal([]byte(tx.Params), ¶ms) + if err != nil { + return nil, err + } + + result := UniversalReceiverHookValue{ + Type: uint64(params.Type_), + Payload: params.Payload, + Return: tx.Return, + } + + return result, nil +} + +func getApproveReturn(height int64, raw map[string]interface{}) (interface{}, error) { + var params ApproveValue + + returnRaw, ok := raw["Return"].(map[string]interface{}) + if !ok { + return nil, fmt.Errorf("Return not found or not a map") + } + + applied, ok := returnRaw["Applied"].(bool) + if !ok { + return nil, fmt.Errorf("Applied not found or not a bool") + } + + code, ok := returnRaw["Code"].(float64) + if !ok { + return nil, fmt.Errorf("Code not found or not a float64") + } + + ret, ok := returnRaw["Ret"].(string) + if !ok { + return nil, fmt.Errorf("Ret not found or not a string") + } + + switch height { + case 11: + params.Return = multisig11.ApproveReturn{ + Applied: applied, + Code: exitcode.ExitCode(code), + Ret: []byte(ret), + } + } + + return params, nil + +} + +func getCancelReturn(height int64, raw map[string]interface{}) (interface{}, error) { + paramsStr, ok := raw["Params"].(string) + if !ok { + return nil, fmt.Errorf("Params not found or not a string") + } + + var paramsRaw map[string]interface{} + err := json.Unmarshal([]byte(paramsStr), ¶msRaw) + if err != nil { + return nil, err + } + + var v CancelValue + err = mapToStruct(paramsRaw, &v) + if err != nil { + return nil, err + } + + return v, nil +} + +func getChangeNumApprovalsThresholdValue(height int64, raw map[string]interface{}) (interface{}, error) { + paramsStr, ok := raw["Params"].(map[string]interface{}) + if !ok { + return nil, fmt.Errorf("Params not found or not a map") + } + + var newValue uint64 + if newThreshold, ok := paramsStr["NewThreshold"].(float64); ok { + newValue = uint64(newThreshold) + } else { + return nil, fmt.Errorf("NewThreshold not found or not a number") + } + var v any + switch height { + case 11: + v = multisig11.ChangeNumApprovalsThresholdParams{ + NewThreshold: newValue, + } + } + + return v, nil +} diff --git a/actors/multisig/verifier.go b/actors/multisig/verifier.go new file mode 100644 index 00000000..6ede15be --- /dev/null +++ b/actors/multisig/verifier.go @@ -0,0 +1,11 @@ +package multisig + +import verifreg11 "github.com/filecoin-project/go-state-types/builtin/v11/verifreg" + +func AddVerifierValue(height int64, txMetadata string) (interface{}, error) { + switch height { + case 11: + return parse[*verifreg11.AddVerifierParams, string](txMetadata, jsonUnmarshaller[*verifreg11.AddVerifierParams]) + } + return nil, nil +} diff --git a/actors/multisig_types.go b/actors/multisig_types.go index 9092b138..78218ce3 100644 --- a/actors/multisig_types.go +++ b/actors/multisig_types.go @@ -1,6 +1,10 @@ package actors -import multisig2 "github.com/filecoin-project/go-state-types/builtin/v14/multisig" +import ( + "io" + + multisig2 "github.com/filecoin-project/go-state-types/builtin/v14/multisig" +) type ApproveValue struct { ID int `json:"ID"` @@ -45,6 +49,7 @@ type TransactionUniversalReceiverHookMetadata struct { } type ChangeOwnerAddressParams struct { + WithCBOR Params string `json:"Params"` } @@ -53,3 +58,14 @@ type InvokeContractParams struct { Params string `json:"Params"` Return string `json:"Return"` } + +type WithCBOR struct { +} + +func (w *WithCBOR) UnmarshalCBOR(reader io.Reader) error { + return nil +} + +func (w *WithCBOR) MarshalCBOR(writer io.Writer) error { + return nil +} diff --git a/actors/paymentChannel/paymentChannel.go b/actors/paymentChannel/paymentChannel.go new file mode 100644 index 00000000..4148cd4f --- /dev/null +++ b/actors/paymentChannel/paymentChannel.go @@ -0,0 +1,76 @@ +package paymentchannel + +import ( + "bytes" + "io" + + paychv10 "github.com/filecoin-project/go-state-types/builtin/v10/paych" + paychv11 "github.com/filecoin-project/go-state-types/builtin/v11/paych" + paychv12 "github.com/filecoin-project/go-state-types/builtin/v12/paych" + paychv13 "github.com/filecoin-project/go-state-types/builtin/v13/paych" + paychv14 "github.com/filecoin-project/go-state-types/builtin/v14/paych" + paychv15 "github.com/filecoin-project/go-state-types/builtin/v15/paych" + paychv8 "github.com/filecoin-project/go-state-types/builtin/v8/paych" + paychv9 "github.com/filecoin-project/go-state-types/builtin/v9/paych" + "github.com/zondax/fil-parser/parser" +) + +type paymentChannelParams interface { + UnmarshalCBOR(io.Reader) error +} + +func PaymentChannelConstructor(height int64, raw []byte) (map[string]interface{}, error) { + switch height { + case 8: + return parse[*paychv8.ConstructorParams](raw) + case 9: + return parse[*paychv9.ConstructorParams](raw) + case 10: + return parse[*paychv10.ConstructorParams](raw) + case 11: + return parse[*paychv11.ConstructorParams](raw) + case 12: + return parse[*paychv12.ConstructorParams](raw) + case 13: + return parse[*paychv13.ConstructorParams](raw) + case 14: + return parse[*paychv14.ConstructorParams](raw) + case 15: + return parse[*paychv15.ConstructorParams](raw) + } + return nil, nil +} + +func UpdateChannelState(height int64, raw []byte) (map[string]interface{}, error) { + switch height { + case 8: + return parse[*paychv8.UpdateChannelStateParams](raw) + case 9: + return parse[*paychv9.UpdateChannelStateParams](raw) + case 10: + return parse[*paychv10.UpdateChannelStateParams](raw) + case 11: + return parse[*paychv11.UpdateChannelStateParams](raw) + case 12: + return parse[*paychv12.UpdateChannelStateParams](raw) + case 13: + return parse[*paychv13.UpdateChannelStateParams](raw) + case 14: + return parse[*paychv14.UpdateChannelStateParams](raw) + case 15: + return parse[*paychv15.UpdateChannelStateParams](raw) + } + return nil, nil +} + +func parse[T paymentChannelParams](raw []byte) (map[string]interface{}, error) { + metadata := make(map[string]interface{}) + reader := bytes.NewReader(raw) + var constructor T + err := constructor.UnmarshalCBOR(reader) + if err != nil { + return metadata, err + } + metadata[parser.ParamsKey] = constructor + return metadata, nil +} diff --git a/actors/power/power.go b/actors/power/power.go new file mode 100644 index 00000000..d84c24b7 --- /dev/null +++ b/actors/power/power.go @@ -0,0 +1,182 @@ +package power + +import ( + "bytes" + "io" + + "github.com/filecoin-project/go-address" + "github.com/filecoin-project/go-state-types/abi" + powerv10 "github.com/filecoin-project/go-state-types/builtin/v10/power" + powerv11 "github.com/filecoin-project/go-state-types/builtin/v11/power" + powerv12 "github.com/filecoin-project/go-state-types/builtin/v12/power" + powerv13 "github.com/filecoin-project/go-state-types/builtin/v13/power" + powerv14 "github.com/filecoin-project/go-state-types/builtin/v14/power" + powerv15 "github.com/filecoin-project/go-state-types/builtin/v15/power" + powerv8 "github.com/filecoin-project/go-state-types/builtin/v8/power" + powerv9 "github.com/filecoin-project/go-state-types/builtin/v9/power" + "github.com/filecoin-project/go-state-types/proof" + "github.com/ipfs/go-cid" + "github.com/zondax/fil-parser/parser" + "github.com/zondax/fil-parser/types" +) + +type powerParams interface { + UnmarshalCBOR(io.Reader) error +} + +type powerReturn interface { + UnmarshalCBOR(io.Reader) error +} + +func getAddressInfo(r powerReturn, msg *parser.LotusMessage) *types.AddressInfo { + createAddressInfo := func(idAddress, robustAddress address.Address, cid cid.Cid) *types.AddressInfo { + return &types.AddressInfo{ + Short: idAddress.String(), + Robust: robustAddress.String(), + ActorType: "miner", + CreationTxCid: cid.String(), + } + } + switch r := r.(type) { + case *powerv8.CreateMinerReturn: + return createAddressInfo(r.IDAddress, r.RobustAddress, msg.Cid) + case *powerv9.CreateMinerReturn: + return createAddressInfo(r.IDAddress, r.RobustAddress, msg.Cid) + case *powerv10.CreateMinerReturn: + return createAddressInfo(r.IDAddress, r.RobustAddress, msg.Cid) + case *powerv11.CreateMinerReturn: + return createAddressInfo(r.IDAddress, r.RobustAddress, msg.Cid) + case *powerv12.CreateMinerReturn: + return createAddressInfo(r.IDAddress, r.RobustAddress, msg.Cid) + case *powerv13.CreateMinerReturn: + return createAddressInfo(r.IDAddress, r.RobustAddress, msg.Cid) + case *powerv14.CreateMinerReturn: + return createAddressInfo(r.IDAddress, r.RobustAddress, msg.Cid) + case *powerv15.CreateMinerReturn: + return createAddressInfo(r.IDAddress, r.RobustAddress, msg.Cid) + } + return nil +} + +func parse[T powerParams, R powerReturn](msg *parser.LotusMessage, raw, rawReturn []byte, customReturn bool) (map[string]interface{}, *types.AddressInfo, error) { + metadata := make(map[string]interface{}) + reader := bytes.NewReader(raw) + var constructor T + err := constructor.UnmarshalCBOR(reader) + if err != nil { + return metadata, nil, err + } + + metadata[parser.ParamsKey] = constructor + if !customReturn { + return metadata, nil, nil + } + + reader = bytes.NewReader(rawReturn) + var r R + err = r.UnmarshalCBOR(reader) + if err != nil { + return metadata, nil, err + } + createdActor := getAddressInfo(r, msg) + metadata[parser.ReturnKey] = createdActor + return metadata, createdActor, nil +} + +func CurrentTotalPower(msg *parser.LotusMessage, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { + switch height { + case 8: + data, _, err := parse[*powerv8.CurrentTotalPowerReturn, *powerv8.CurrentTotalPowerReturn](msg, raw, rawReturn, false) + return data, err + case 9: + data, _, err := parse[*powerv9.CurrentTotalPowerReturn, *powerv9.CurrentTotalPowerReturn](msg, raw, rawReturn, false) + return data, err + } + return nil, nil +} + +func SubmitPoRepForBulkVerify(msg *parser.LotusMessage, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { + data, _, err := parse[*proof.SealVerifyInfo, *proof.SealVerifyInfo](msg, raw, rawReturn, false) + return data, err +} + +func PowerConstructor(height int64, msg *parser.LotusMessage, raw []byte) (map[string]interface{}, error) { + switch height { + case 8: + data, _, err := parse[*powerv8.MinerConstructorParams, *powerv8.MinerConstructorParams](msg, raw, nil, false) + return data, err + } + return nil, nil +} + +func CreateMiner(msg *parser.LotusMessage, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { + switch height { + case 8: + data, _, err := parse[*powerv8.CreateMinerParams, *powerv8.CreateMinerReturn](msg, raw, rawReturn, true) + return data, err + } + return nil, nil +} + +func EnrollCronEvent(msg *parser.LotusMessage, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { + switch height { + case 8: + data, _, err := parse[*powerv8.EnrollCronEventParams, *powerv8.EnrollCronEventParams](msg, raw, rawReturn, true) + return data, err + } + return nil, nil +} + +func UpdateClaimedPower(msg *parser.LotusMessage, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { + switch height { + case 8: + data, _, err := parse[*powerv8.UpdateClaimedPowerParams, *powerv8.UpdateClaimedPowerParams](msg, raw, rawReturn, true) + return data, err + } + return nil, nil +} + +func UpdatePledgeTotal(msg *parser.LotusMessage, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { + switch height { + case 8: + data, _, err := parse[*abi.TokenAmount, *abi.TokenAmount](msg, raw, rawReturn, false) + return data, err + } + return nil, nil +} + +func NetworkRawPower(msg *parser.LotusMessage, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { + switch height { + case 8: + data, _, err := parse[*powerv8.NetworkRawPowerReturn, *powerv8.NetworkRawPowerReturn](msg, raw, rawReturn, false) + return data, err + } + return nil, nil +} + +func MinerRawPower(msg *parser.LotusMessage, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { + switch height { + case 8: + data, _, err := parse[*powerv8.MinerRawPowerParams, *powerv8.MinerRawPowerReturn](msg, raw, rawReturn, true) + return data, err + } + return nil, nil +} + +func MinerCount(msg *parser.LotusMessage, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { + switch height { + case 8: + data, _, err := parse[*powerv8.MinerCountReturn, *powerv8.MinerCountReturn](msg, raw, rawReturn, false) + return data, err + } + return nil, nil +} + +func MinerConsensusCount(msg *parser.LotusMessage, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { + switch height { + case 8: + data, _, err := parse[*powerv8.MinerConsensusCountReturn, *powerv8.MinerConsensusCountReturn](msg, raw, rawReturn, false) + return data, err + } + return nil, nil +} diff --git a/actors/reward/reward.go b/actors/reward/reward.go new file mode 100644 index 00000000..8fa1eb86 --- /dev/null +++ b/actors/reward/reward.go @@ -0,0 +1,55 @@ +package reward + +import ( + "bytes" + "io" + + "github.com/filecoin-project/go-state-types/abi" + rewardv11 "github.com/filecoin-project/go-state-types/builtin/v11/reward" + rewardv8 "github.com/filecoin-project/go-state-types/builtin/v8/reward" + "github.com/zondax/fil-parser/parser" +) + +type rewardParams interface { + UnmarshalCBOR(io.Reader) error +} + +func parse[T rewardParams](raw []byte) (map[string]interface{}, error) { + metadata := make(map[string]interface{}) + reader := bytes.NewReader(raw) + var params T + err := params.UnmarshalCBOR(reader) + if err != nil { + return metadata, err + } + metadata[parser.ParamsKey] = params + return metadata, nil +} + +func RewardConstructor(height int64, raw []byte) (map[string]interface{}, error) { + return parse[*abi.StoragePower](raw) +} + +func AwardBlockReward(height int64, raw []byte) (map[string]interface{}, error) { + switch height { + case 8: + return parse[*rewardv8.AwardBlockRewardParams](raw) + case 11: + return parse[*rewardv11.AwardBlockRewardParams](raw) + } + return nil, nil +} + +func UpdateNetworkKPI(height int64, raw []byte) (map[string]interface{}, error) { + return parse[*abi.StoragePower](raw) +} + +func ThisEpochReward(height int64, raw []byte) (map[string]interface{}, error) { + switch height { + case 8: + return parse[*rewardv8.ThisEpochRewardReturn](raw) + case 11: + return parse[*rewardv11.ThisEpochRewardReturn](raw) + } + return nil, nil +} diff --git a/actors/verifiedRegistry/verifiedRegistry.go b/actors/verifiedRegistry/verifiedRegistry.go new file mode 100644 index 00000000..773841b9 --- /dev/null +++ b/actors/verifiedRegistry/verifiedRegistry.go @@ -0,0 +1,175 @@ +package verifiedregistry + +import ( + "bytes" + "io" + + "github.com/filecoin-project/go-address" + verifregv11 "github.com/filecoin-project/go-state-types/builtin/v11/verifreg" + verifregv8 "github.com/filecoin-project/go-state-types/builtin/v8/verifreg" + "github.com/zondax/fil-parser/parser" +) + +type verifiedRegistryParams interface { + UnmarshalCBOR(io.Reader) error +} + +type verifiedRegistryReturn interface { + UnmarshalCBOR(io.Reader) error +} + +func parse[T verifiedRegistryParams, R verifiedRegistryReturn](raw, rawReturn []byte, customReturn bool) (map[string]interface{}, error) { + metadata := make(map[string]interface{}) + reader := bytes.NewReader(raw) + var params T + err := params.UnmarshalCBOR(reader) + if err != nil { + return metadata, err + } + metadata[parser.ParamsKey] = params + if customReturn { + return metadata, nil + } + reader = bytes.NewReader(rawReturn) + var r R + err = r.UnmarshalCBOR(reader) + if err != nil { + return metadata, err + } + metadata[parser.ReturnKey] = r + return metadata, nil +} + +func AddVerifier(height int64, raw []byte) (map[string]interface{}, error) { + switch height { + case 8: + return parse[*verifregv8.AddVerifierParams, *verifregv8.AddVerifierParams](raw, nil, false) + case 11: + return parse[*verifregv11.AddVerifierParams, *verifregv11.AddVerifierParams](raw, nil, false) + } + return nil, nil +} + +func RemoveVerifier(height int64, raw []byte) (map[string]interface{}, error) { + return parse[*address.Address, *address.Address](raw, nil, false) +} + +func AddVerifiedClient(height int64, raw []byte) (map[string]interface{}, error) { + switch height { + case 8: + return parse[*verifregv8.AddVerifiedClientParams, *verifregv8.AddVerifiedClientParams](raw, nil, false) + case 11: + return parse[*verifregv11.AddVerifiedClientParams, *verifregv11.AddVerifiedClientParams](raw, nil, false) + } + return nil, nil +} + +func UseBytes(height int64, raw []byte) (map[string]interface{}, error) { + switch height { + case 8: + return parse[*verifregv8.UseBytesParams, *verifregv8.UseBytesParams](raw, nil, false) + case 11: + return parse[*verifregv11.UseBytesParams, *verifregv11.UseBytesParams](raw, nil, false) + } + return nil, nil +} + +func RestoreBytes(height int64, raw []byte) (map[string]interface{}, error) { + switch height { + case 8: + return parse[*verifregv8.RestoreBytesParams, *verifregv8.RestoreBytesParams](raw, nil, false) + case 11: + return parse[*verifregv11.RestoreBytesParams, *verifregv11.RestoreBytesParams](raw, nil, false) + } + return nil, nil +} + +func RemoveVerifiedClientDataCap(height int64, raw []byte) (map[string]interface{}, error) { + switch height { + case 8: + return parse[*verifregv8.DataCap, *verifregv8.DataCap](raw, nil, false) + case 11: + return parse[*verifregv11.DataCap, *verifregv11.DataCap](raw, nil, false) + } + return nil, nil +} + +func RemoveExpiredAllocations(height int64, raw, rawReturn []byte) (map[string]interface{}, error) { + switch height { + case 8: + return parse[*verifregv8.RemoveExpiredAllocationsParams, *verifregv8.RemoveExpiredAllocationsReturn](raw, rawReturn, true) + case 11: + return parse[*verifregv11.RemoveExpiredAllocationsParams, *verifregv11.RemoveExpiredAllocationsReturn](raw, rawReturn, true) + } + return nil, nil +} + +func Deprecated1(height int64, raw []byte) (map[string]interface{}, error) { + switch height { + case 8: + return parse[*verifregv8.RestoreBytesParams, *verifregv8.RestoreBytesParams](raw, nil, false) + case 11: + return parse[*verifregv11.RestoreBytesParams, *verifregv11.RestoreBytesParams](raw, nil, false) + } + return nil, nil +} + +func Deprecated2(height int64, raw []byte) (map[string]interface{}, error) { + switch height { + case 8: + return parse[*verifregv8.UseBytesParams, *verifregv8.UseBytesParams](raw, nil, false) + case 11: + return parse[*verifregv11.UseBytesParams, *verifregv11.UseBytesParams](raw, nil, false) + } + return nil, nil +} + +func ClaimAllocations(height int64, raw, rawReturn []byte) (map[string]interface{}, error) { + switch height { + case 8: + return parse[*verifregv8.ClaimAllocationsParams, *verifregv8.ClaimAllocationsReturn](raw, rawReturn, true) + case 11: + return parse[*verifregv11.ClaimAllocationsParams, *verifregv11.ClaimAllocationsReturn](raw, rawReturn, true) + } + return nil, nil +} + +func GetClaims(height int64, raw, rawReturn []byte) (map[string]interface{}, error) { + switch height { + case 8: + return parse[*verifregv8.GetClaimsParams, *verifregv8.GetClaimsReturn](raw, rawReturn, true) + case 11: + return parse[*verifregv11.GetClaimsParams, *verifregv11.GetClaimsReturn](raw, rawReturn, true) + } + return nil, nil +} + +func ExtendClaimTerms(height int64, raw, rawReturn []byte) (map[string]interface{}, error) { + switch height { + case 8: + return parse[*verifregv8.ExtendClaimTermsParams, *verifregv8.ExtendClaimTermsReturn](raw, rawReturn, true) + case 11: + return parse[*verifregv11.ExtendClaimTermsParams, *verifregv11.ExtendClaimTermsReturn](raw, rawReturn, true) + } + return nil, nil +} + +func RemoveExpiredClaims(height int64, raw, rawReturn []byte) (map[string]interface{}, error) { + switch height { + case 8: + return parse[*verifregv8.RemoveExpiredClaimsParams, *verifregv8.RemoveExpiredClaimsReturn](raw, rawReturn, true) + case 11: + return parse[*verifregv11.RemoveExpiredClaimsParams, *verifregv11.RemoveExpiredClaimsReturn](raw, rawReturn, true) + } + return nil, nil +} + +func VerifregUniversalReceiverHook(height int64, raw, rawReturn []byte) (map[string]interface{}, error) { + switch height { + case 8: + return parse[*verifregv8.UniversalReceiverParams, *verifregv8.AllocationsResponse](raw, rawReturn, true) + case 11: + return parse[*verifregv11.UniversalReceiverParams, *verifregv11.AllocationsResponse](raw, rawReturn, true) + } + return nil, nil +} From 2eb41aa51d8b3af1ec68ea77fd5f90461f380123 Mon Sep 17 00:00:00 2001 From: Eric Mokaya Date: Tue, 21 Jan 2025 20:58:18 +0300 Subject: [PATCH 04/16] feat: standardize folder structure --- actors/account/account.go | 15 +- actors/account/authenticate.go | 73 ------ actors/account/generic.go | 25 ++ actors/account/types.go | 13 + actors/cron/constructor.go | 59 ----- actors/cron/cron.go | 24 +- actors/cron/generic.go | 18 ++ actors/cron/types.go | 9 + actors/datacap/allowance.go | 207 +++------------- actors/datacap/burn.go | 180 ++++---------- actors/datacap/granularity.go | 72 ++---- actors/datacap/mint.go | 71 ++---- actors/datacap/transfer.go | 77 ++---- actors/eam/create.go | 78 ++++++ actors/eam/eam.go | 99 ++++++++ actors/eam/generic.go | 78 ++++++ actors/eam/return.go | 261 -------------------- actors/eam/types.go | 7 + actors/evm/evm.go | 197 ++++++++------- actors/evm/generic.go | 80 ++++++ actors/evm/types.go | 19 ++ actors/init/generic.go | 43 ++++ actors/init/init.go | 45 ---- actors/init/types.go | 11 + actors/market/generic.go | 32 +++ actors/market/market.go | 44 ---- actors/market/types.go | 11 + actors/market/utils.go | 10 + actors/miner/generic.go | 29 +++ actors/miner/miner.go | 33 --- actors/miner/types.go | 11 + actors/multisig/generic.go | 37 +++ actors/multisig/types.go | 39 +-- actors/multisig/utils.go | 51 +--- actors/paymentChannel/generic.go | 19 ++ actors/paymentChannel/paymentChannel.go | 14 -- actors/power/generic.go | 33 +++ actors/power/power.go | 75 ------ actors/power/types.go | 11 + actors/power/utils.go | 46 ++++ actors/reward/generic.go | 19 ++ actors/reward/reward.go | 20 -- actors/reward/types.go | 7 + actors/verifiedRegistry/generic.go | 29 +++ actors/verifiedRegistry/types.go | 11 + actors/verifiedRegistry/verifiedRegistry.go | 34 --- 46 files changed, 1094 insertions(+), 1282 deletions(-) delete mode 100644 actors/account/authenticate.go create mode 100644 actors/account/generic.go create mode 100644 actors/account/types.go delete mode 100644 actors/cron/constructor.go create mode 100644 actors/cron/generic.go create mode 100644 actors/cron/types.go create mode 100644 actors/eam/create.go create mode 100644 actors/eam/eam.go create mode 100644 actors/eam/generic.go delete mode 100644 actors/eam/return.go create mode 100644 actors/eam/types.go create mode 100644 actors/evm/generic.go create mode 100644 actors/evm/types.go create mode 100644 actors/init/generic.go create mode 100644 actors/init/types.go create mode 100644 actors/market/generic.go create mode 100644 actors/market/types.go create mode 100644 actors/market/utils.go create mode 100644 actors/miner/generic.go create mode 100644 actors/miner/types.go create mode 100644 actors/multisig/generic.go create mode 100644 actors/paymentChannel/generic.go create mode 100644 actors/power/generic.go create mode 100644 actors/power/types.go create mode 100644 actors/power/utils.go create mode 100644 actors/reward/generic.go create mode 100644 actors/reward/types.go create mode 100644 actors/verifiedRegistry/generic.go create mode 100644 actors/verifiedRegistry/types.go diff --git a/actors/account/account.go b/actors/account/account.go index 6f7cf203..69814be2 100644 --- a/actors/account/account.go +++ b/actors/account/account.go @@ -6,6 +6,11 @@ import ( "fmt" "github.com/filecoin-project/go-address" + accountv10 "github.com/filecoin-project/go-state-types/builtin/v10/account" + accountv11 "github.com/filecoin-project/go-state-types/builtin/v11/account" + accountv9 "github.com/filecoin-project/go-state-types/builtin/v11/account" + accountv14 "github.com/filecoin-project/go-state-types/builtin/v14/account" + accountv15 "github.com/filecoin-project/go-state-types/builtin/v15/account" "github.com/zondax/fil-parser/parser" ) @@ -27,15 +32,15 @@ func AuthenticateMessage(height int64, raw, rawReturn []byte) (map[string]interf case 8: return nil, fmt.Errorf("not supported") case 9: - return authenticateMessagev9(raw, rawReturn) + return authenticateMessageGeneric[*accountv9.AuthenticateMessageParams, *accountv9.AuthenticateMessageParams](raw, rawReturn, &accountv9.AuthenticateMessageParams{}) case 10: - return authenticateMessagev10(raw, rawReturn) + return authenticateMessageGeneric[*accountv10.AuthenticateMessageParams, *accountv10.AuthenticateMessageParams](raw, rawReturn, &accountv10.AuthenticateMessageParams{}) case 11: - return authenticateMessagev11(raw, rawReturn) + return authenticateMessageGeneric[*accountv11.AuthenticateMessageParams, *accountv11.AuthenticateMessageParams](raw, rawReturn, &accountv11.AuthenticateMessageParams{}) case 14: - return authenticateMessagev14(raw, rawReturn) + return authenticateMessageGeneric[*accountv14.AuthenticateMessageParams, *accountv14.AuthenticateMessageParams](raw, rawReturn, &accountv14.AuthenticateMessageParams{}) case 15: - return authenticateMessagev15(raw, rawReturn) + return authenticateMessageGeneric[*accountv15.AuthenticateMessageParams, *accountv15.AuthenticateMessageParams](raw, rawReturn, &accountv15.AuthenticateMessageParams{}) } return nil, nil } diff --git a/actors/account/authenticate.go b/actors/account/authenticate.go deleted file mode 100644 index 8bc240dc..00000000 --- a/actors/account/authenticate.go +++ /dev/null @@ -1,73 +0,0 @@ -package account - -import ( - "bytes" - "io" - - accountv10 "github.com/filecoin-project/go-state-types/builtin/v10/account" - accountv11 "github.com/filecoin-project/go-state-types/builtin/v11/account" - accountv9 "github.com/filecoin-project/go-state-types/builtin/v11/account" - accountv12 "github.com/filecoin-project/go-state-types/builtin/v12/account" - accountv13 "github.com/filecoin-project/go-state-types/builtin/v13/account" - accountv14 "github.com/filecoin-project/go-state-types/builtin/v14/account" - accountv15 "github.com/filecoin-project/go-state-types/builtin/v15/account" - - typegen "github.com/whyrusleeping/cbor-gen" - "github.com/zondax/fil-parser/parser" -) - -type authenticateMessageParams interface { - UnmarshalCBOR(r io.Reader) error -} - -func authenticateMessageGeneric[P authenticateMessageParams](raw, rawReturn []byte, params P) (map[string]interface{}, error) { - metadata := make(map[string]interface{}) - reader := bytes.NewReader(raw) - err := params.UnmarshalCBOR(reader) - if err != nil { - return metadata, err - } - metadata[parser.ParamsKey] = params - reader = bytes.NewReader(rawReturn) - var expiredReturn typegen.CborBool - err = expiredReturn.UnmarshalCBOR(reader) - if err != nil { - return metadata, err - } - metadata[parser.ReturnKey] = expiredReturn - return metadata, nil -} - -// Version-specific wrappers - -func authenticateMessagev15(raw, rawReturn []byte) (map[string]interface{}, error) { - return authenticateMessageGeneric[*accountv15.AuthenticateMessageParams](raw, rawReturn, &accountv15.AuthenticateMessageParams{}) -} - -func authenticateMessagev14(raw, rawReturn []byte) (map[string]interface{}, error) { - return authenticateMessageGeneric[*accountv14.AuthenticateMessageParams](raw, rawReturn, &accountv14.AuthenticateMessageParams{}) -} - -func authenticateMessagev13(raw, rawReturn []byte) (map[string]interface{}, error) { - return authenticateMessageGeneric[*accountv13.AuthenticateMessageParams](raw, rawReturn, &accountv13.AuthenticateMessageParams{}) -} - -func authenticateMessagev12(raw, rawReturn []byte) (map[string]interface{}, error) { - return authenticateMessageGeneric[*accountv12.AuthenticateMessageParams](raw, rawReturn, &accountv12.AuthenticateMessageParams{}) -} - -func authenticateMessagev11(raw, rawReturn []byte) (map[string]interface{}, error) { - return authenticateMessageGeneric[*accountv11.AuthenticateMessageParams](raw, rawReturn, &accountv11.AuthenticateMessageParams{}) -} - -func authenticateMessagev10(raw, rawReturn []byte) (map[string]interface{}, error) { - return authenticateMessageGeneric[*accountv10.AuthenticateMessageParams](raw, rawReturn, &accountv10.AuthenticateMessageParams{}) -} - -func authenticateMessagev9(raw, rawReturn []byte) (map[string]interface{}, error) { - return authenticateMessageGeneric[*accountv9.AuthenticateMessageParams](raw, rawReturn, &accountv9.AuthenticateMessageParams{}) -} - -// func authenticateMessagev8(raw, rawReturn []byte) (map[string]interface{}, error) { -// return authenticateMessageGeneric[*accountv8.AuthenticateMessageParams](raw, rawReturn, &accountv8.AuthenticateMessageParams{}) -// } diff --git a/actors/account/generic.go b/actors/account/generic.go new file mode 100644 index 00000000..56548a59 --- /dev/null +++ b/actors/account/generic.go @@ -0,0 +1,25 @@ +package account + +import ( + "bytes" + + "github.com/zondax/fil-parser/parser" +) + +func authenticateMessageGeneric[P authenticateMessageParams, R authenticateMessageReturn](raw, rawReturn []byte, params P) (map[string]interface{}, error) { + metadata := make(map[string]interface{}) + reader := bytes.NewReader(raw) + err := params.UnmarshalCBOR(reader) + if err != nil { + return metadata, err + } + metadata[parser.ParamsKey] = params + reader = bytes.NewReader(rawReturn) + var r R + err = r.UnmarshalCBOR(reader) + if err != nil { + return metadata, err + } + metadata[parser.ReturnKey] = r + return metadata, nil +} diff --git a/actors/account/types.go b/actors/account/types.go new file mode 100644 index 00000000..965a227f --- /dev/null +++ b/actors/account/types.go @@ -0,0 +1,13 @@ +package account + +import ( + "io" +) + +type authenticateMessageParams interface { + UnmarshalCBOR(r io.Reader) error +} + +type authenticateMessageReturn interface { + UnmarshalCBOR(r io.Reader) error +} diff --git a/actors/cron/constructor.go b/actors/cron/constructor.go deleted file mode 100644 index 6cc1021c..00000000 --- a/actors/cron/constructor.go +++ /dev/null @@ -1,59 +0,0 @@ -package cron - -import ( - "bytes" - "io" - - cronv2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/cron" - cronv3 "github.com/filecoin-project/specs-actors/v3/actors/builtin/cron" - cronv4 "github.com/filecoin-project/specs-actors/v4/actors/builtin/cron" - cronv5 "github.com/filecoin-project/specs-actors/v5/actors/builtin/cron" - cronv6 "github.com/filecoin-project/specs-actors/v6/actors/builtin/cron" - cronv7 "github.com/filecoin-project/specs-actors/v7/actors/builtin/cron" - cronv8 "github.com/filecoin-project/specs-actors/v8/actors/builtin/cron" - - "github.com/zondax/fil-parser/parser" -) - -type cronConstructorParams interface { - UnmarshalCBOR(r io.Reader) error -} - -func cronConstructorv8(raw []byte) (map[string]interface{}, error) { - return cronConstructorGeneric[*cronv8.ConstructorParams](raw, &cronv8.ConstructorParams{}) -} - -func cronConstructorv7(raw []byte) (map[string]interface{}, error) { - return cronConstructorGeneric[*cronv7.ConstructorParams](raw, &cronv7.ConstructorParams{}) -} - -func cronConstructorv6(raw []byte) (map[string]interface{}, error) { - return cronConstructorGeneric[*cronv6.ConstructorParams](raw, &cronv6.ConstructorParams{}) -} - -func cronConstructorv5(raw []byte) (map[string]interface{}, error) { - return cronConstructorGeneric[*cronv5.ConstructorParams](raw, &cronv5.ConstructorParams{}) -} - -func cronConstructorv4(raw []byte) (map[string]interface{}, error) { - return cronConstructorGeneric[*cronv4.ConstructorParams](raw, &cronv4.ConstructorParams{}) -} - -func cronConstructorv3(raw []byte) (map[string]interface{}, error) { - return cronConstructorGeneric[*cronv3.ConstructorParams](raw, &cronv3.ConstructorParams{}) -} - -func cronConstructorv2(raw []byte) (map[string]interface{}, error) { - return cronConstructorGeneric[*cronv2.ConstructorParams](raw, &cronv2.ConstructorParams{}) -} - -func cronConstructorGeneric[P cronConstructorParams](raw []byte, params P) (map[string]interface{}, error) { - metadata := make(map[string]interface{}) - reader := bytes.NewReader(raw) - err := params.UnmarshalCBOR(reader) - if err != nil { - return metadata, err - } - metadata[parser.ParamsKey] = params - return metadata, nil -} diff --git a/actors/cron/cron.go b/actors/cron/cron.go index 631fd738..1f60e692 100644 --- a/actors/cron/cron.go +++ b/actors/cron/cron.go @@ -1,22 +1,32 @@ package cron +import ( + cronv2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/cron" + cronv3 "github.com/filecoin-project/specs-actors/v3/actors/builtin/cron" + cronv4 "github.com/filecoin-project/specs-actors/v4/actors/builtin/cron" + cronv5 "github.com/filecoin-project/specs-actors/v5/actors/builtin/cron" + cronv6 "github.com/filecoin-project/specs-actors/v6/actors/builtin/cron" + cronv7 "github.com/filecoin-project/specs-actors/v7/actors/builtin/cron" + cronv8 "github.com/filecoin-project/specs-actors/v8/actors/builtin/cron" +) + // TODO: update to correct height ranges func CronConstructor(height uint64, raw []byte) (map[string]interface{}, error) { switch height { case 8: - return cronConstructorv8(raw) + return cronConstructorGeneric[*cronv8.ConstructorParams](raw, &cronv8.ConstructorParams{}) case 7: - return cronConstructorv7(raw) + return cronConstructorGeneric[*cronv7.ConstructorParams](raw, &cronv7.ConstructorParams{}) case 6: - return cronConstructorv6(raw) + return cronConstructorGeneric[*cronv6.ConstructorParams](raw, &cronv6.ConstructorParams{}) case 5: - return cronConstructorv5(raw) + return cronConstructorGeneric[*cronv5.ConstructorParams](raw, &cronv5.ConstructorParams{}) case 4: - return cronConstructorv4(raw) + return cronConstructorGeneric[*cronv4.ConstructorParams](raw, &cronv4.ConstructorParams{}) case 3: - return cronConstructorv3(raw) + return cronConstructorGeneric[*cronv3.ConstructorParams](raw, &cronv3.ConstructorParams{}) case 2: - return cronConstructorv2(raw) + return cronConstructorGeneric[*cronv2.ConstructorParams](raw, &cronv2.ConstructorParams{}) } return nil, nil } diff --git a/actors/cron/generic.go b/actors/cron/generic.go new file mode 100644 index 00000000..276e7d9c --- /dev/null +++ b/actors/cron/generic.go @@ -0,0 +1,18 @@ +package cron + +import ( + "bytes" + + "github.com/zondax/fil-parser/parser" +) + +func cronConstructorGeneric[P cronConstructorParams](raw []byte, params P) (map[string]interface{}, error) { + metadata := make(map[string]interface{}) + reader := bytes.NewReader(raw) + err := params.UnmarshalCBOR(reader) + if err != nil { + return metadata, err + } + metadata[parser.ParamsKey] = params + return metadata, nil +} diff --git a/actors/cron/types.go b/actors/cron/types.go new file mode 100644 index 00000000..25a99a64 --- /dev/null +++ b/actors/cron/types.go @@ -0,0 +1,9 @@ +package cron + +import ( + "io" +) + +type cronConstructorParams interface { + UnmarshalCBOR(r io.Reader) error +} diff --git a/actors/datacap/allowance.go b/actors/datacap/allowance.go index 82a81ab7..a1e43410 100644 --- a/actors/datacap/allowance.go +++ b/actors/datacap/allowance.go @@ -7,39 +7,49 @@ import ( "github.com/filecoin-project/go-state-types/abi" datacapv10 "github.com/filecoin-project/go-state-types/builtin/v10/datacap" datacapv11 "github.com/filecoin-project/go-state-types/builtin/v11/datacap" - datacapv12 "github.com/filecoin-project/go-state-types/builtin/v12/datacap" - datacapv13 "github.com/filecoin-project/go-state-types/builtin/v13/datacap" datacapv14 "github.com/filecoin-project/go-state-types/builtin/v14/datacap" datacapv15 "github.com/filecoin-project/go-state-types/builtin/v15/datacap" datacapv9 "github.com/filecoin-project/go-state-types/builtin/v9/datacap" "github.com/zondax/fil-parser/parser" ) -type ( - increaseAllowanceParams = unmarshalCBOR - decreaseAllowanceParams = unmarshalCBOR - revokeAllowanceParams = unmarshalCBOR - allowanceParams = unmarshalCBOR -) - type allowanceParamsInterface interface { unmarshalCBOR } +func allowanceGeneric[T allowanceParamsInterface](raw []byte, rawReturn []byte, params T) (map[string]interface{}, error) { + metadata := make(map[string]interface{}) + reader := bytes.NewReader(raw) + err := params.UnmarshalCBOR(reader) + if err != nil { + return metadata, err + } + metadata[parser.ParamsKey] = params + + reader = bytes.NewReader(rawReturn) + var r abi.TokenAmount + err = r.UnmarshalCBOR(reader) + if err != nil { + return metadata, err + } + metadata[parser.ReturnKey] = r + return metadata, nil +} + func IncreaseAllowance(height uint64, raw, rawReturn []byte) (map[string]interface{}, error) { switch height { case 8: return nil, fmt.Errorf("not supported") case 9: - return increaseAllowanceExportedv9(raw, rawReturn) + return allowanceGeneric[*datacapv9.IncreaseAllowanceParams](raw, rawReturn, &datacapv9.IncreaseAllowanceParams{}) case 10: - return increaseAllowanceExportedv10(raw, rawReturn) + return allowanceGeneric[*datacapv10.IncreaseAllowanceParams](raw, rawReturn, &datacapv10.IncreaseAllowanceParams{}) case 11: - return increaseAllowanceExportedv11(raw, rawReturn) + return allowanceGeneric[*datacapv11.IncreaseAllowanceParams](raw, rawReturn, &datacapv11.IncreaseAllowanceParams{}) case 14: - return increaseAllowanceExportedv14(raw, rawReturn) + return allowanceGeneric[*datacapv14.IncreaseAllowanceParams](raw, rawReturn, &datacapv14.IncreaseAllowanceParams{}) case 15: - return increaseAllowanceExportedv15(raw, rawReturn) + return allowanceGeneric[*datacapv15.IncreaseAllowanceParams](raw, rawReturn, &datacapv15.IncreaseAllowanceParams{}) } return nil, fmt.Errorf("not supported") } @@ -49,15 +59,15 @@ func DecreaseAllowance(height uint64, raw, rawReturn []byte) (map[string]interfa case 8: return nil, fmt.Errorf("not supported") case 9: - return decreaseAllowanceExportedv9(raw, rawReturn) + return allowanceGeneric[*datacapv9.DecreaseAllowanceParams](raw, rawReturn, &datacapv9.DecreaseAllowanceParams{}) case 10: - return decreaseAllowanceExportedv10(raw, rawReturn) + return allowanceGeneric[*datacapv10.DecreaseAllowanceParams](raw, rawReturn, &datacapv10.DecreaseAllowanceParams{}) case 11: - return decreaseAllowanceExportedv11(raw, rawReturn) + return allowanceGeneric[*datacapv11.DecreaseAllowanceParams](raw, rawReturn, &datacapv11.DecreaseAllowanceParams{}) case 14: - return decreaseAllowanceExportedv14(raw, rawReturn) + return allowanceGeneric[*datacapv14.DecreaseAllowanceParams](raw, rawReturn, &datacapv14.DecreaseAllowanceParams{}) case 15: - return decreaseAllowanceExportedv15(raw, rawReturn) + return allowanceGeneric[*datacapv15.DecreaseAllowanceParams](raw, rawReturn, &datacapv15.DecreaseAllowanceParams{}) } return nil, fmt.Errorf("not supported") } @@ -67,15 +77,15 @@ func RevokeAllowance(height uint64, raw, rawReturn []byte) (map[string]interface case 8: return nil, fmt.Errorf("not supported") case 9: - return revokeAllowanceExportedv9(raw, rawReturn) + return allowanceGeneric[*datacapv9.RevokeAllowanceParams](raw, rawReturn, &datacapv9.RevokeAllowanceParams{}) case 10: - return revokeAllowanceExportedv10(raw, rawReturn) + return allowanceGeneric[*datacapv10.RevokeAllowanceParams](raw, rawReturn, &datacapv10.RevokeAllowanceParams{}) case 11: - return revokeAllowanceExportedv11(raw, rawReturn) + return allowanceGeneric[*datacapv11.RevokeAllowanceParams](raw, rawReturn, &datacapv11.RevokeAllowanceParams{}) case 14: - return revokeAllowanceExportedv14(raw, rawReturn) + return allowanceGeneric[*datacapv14.RevokeAllowanceParams](raw, rawReturn, &datacapv14.RevokeAllowanceParams{}) case 15: - return revokeAllowanceExportedv15(raw, rawReturn) + return allowanceGeneric[*datacapv15.RevokeAllowanceParams](raw, rawReturn, &datacapv15.RevokeAllowanceParams{}) } return nil, fmt.Errorf("not supported") } @@ -85,154 +95,15 @@ func GetAllowance(height uint64, raw, rawReturn []byte) (map[string]interface{}, case 8: return nil, fmt.Errorf("not supported") case 9: - return allowanceExportedv9(raw, rawReturn) + return allowanceGeneric[*datacapv9.GetAllowanceParams](raw, rawReturn, &datacapv9.GetAllowanceParams{}) case 10: - return allowanceExportedv10(raw, rawReturn) + return allowanceGeneric[*datacapv10.GetAllowanceParams](raw, rawReturn, &datacapv10.GetAllowanceParams{}) case 11: - return allowanceExportedv11(raw, rawReturn) + return allowanceGeneric[*datacapv11.GetAllowanceParams](raw, rawReturn, &datacapv11.GetAllowanceParams{}) case 14: - return allowanceExportedv14(raw, rawReturn) + return allowanceGeneric[*datacapv14.GetAllowanceParams](raw, rawReturn, &datacapv14.GetAllowanceParams{}) case 15: - return allowanceExportedv15(raw, rawReturn) + return allowanceGeneric[*datacapv15.GetAllowanceParams](raw, rawReturn, &datacapv15.GetAllowanceParams{}) } return nil, fmt.Errorf("not supported") } - -func allowanceGeneric[T allowanceParamsInterface](raw []byte, rawReturn []byte, params T) (map[string]interface{}, error) { - metadata := make(map[string]interface{}) - reader := bytes.NewReader(raw) - err := params.UnmarshalCBOR(reader) - if err != nil { - return metadata, err - } - metadata[parser.ParamsKey] = params - - reader = bytes.NewReader(rawReturn) - var r abi.TokenAmount - err = r.UnmarshalCBOR(reader) - if err != nil { - return metadata, err - } - metadata[parser.ReturnKey] = r - return metadata, nil -} - -// Increase Allowance - -func increaseAllowanceExportedv9(raw, rawReturn []byte) (map[string]interface{}, error) { - return allowanceGeneric(raw, rawReturn, &datacapv9.IncreaseAllowanceParams{}) -} - -func increaseAllowanceExportedv10(raw, rawReturn []byte) (map[string]interface{}, error) { - return allowanceGeneric(raw, rawReturn, &datacapv10.IncreaseAllowanceParams{}) -} - -func increaseAllowanceExportedv11(raw, rawReturn []byte) (map[string]interface{}, error) { - return allowanceGeneric(raw, rawReturn, &datacapv11.IncreaseAllowanceParams{}) -} - -func increaseAllowanceExportedv12(raw, rawReturn []byte) (map[string]interface{}, error) { - return allowanceGeneric(raw, rawReturn, &datacapv12.IncreaseAllowanceParams{}) -} - -func increaseAllowanceExportedv13(raw, rawReturn []byte) (map[string]interface{}, error) { - return allowanceGeneric(raw, rawReturn, &datacapv13.IncreaseAllowanceParams{}) -} - -func increaseAllowanceExportedv14(raw, rawReturn []byte) (map[string]interface{}, error) { - return allowanceGeneric(raw, rawReturn, &datacapv14.IncreaseAllowanceParams{}) -} - -func increaseAllowanceExportedv15(raw, rawReturn []byte) (map[string]interface{}, error) { - return allowanceGeneric(raw, rawReturn, &datacapv15.IncreaseAllowanceParams{}) -} - -// Decrease Allowance - -func decreaseAllowanceExportedv9(raw, rawReturn []byte) (map[string]interface{}, error) { - return allowanceGeneric(raw, rawReturn, &datacapv9.DecreaseAllowanceParams{}) -} - -func decreaseAllowanceExportedv10(raw, rawReturn []byte) (map[string]interface{}, error) { - return allowanceGeneric(raw, rawReturn, &datacapv10.DecreaseAllowanceParams{}) -} - -func decreaseAllowanceExportedv11(raw, rawReturn []byte) (map[string]interface{}, error) { - return allowanceGeneric(raw, rawReturn, &datacapv11.DecreaseAllowanceParams{}) -} - -func decreaseAllowanceExportedv12(raw, rawReturn []byte) (map[string]interface{}, error) { - return allowanceGeneric(raw, rawReturn, &datacapv12.DecreaseAllowanceParams{}) -} - -func decreaseAllowanceExportedv13(raw, rawReturn []byte) (map[string]interface{}, error) { - return allowanceGeneric(raw, rawReturn, &datacapv13.DecreaseAllowanceParams{}) -} - -func decreaseAllowanceExportedv14(raw, rawReturn []byte) (map[string]interface{}, error) { - return allowanceGeneric(raw, rawReturn, &datacapv14.DecreaseAllowanceParams{}) -} - -func decreaseAllowanceExportedv15(raw, rawReturn []byte) (map[string]interface{}, error) { - return allowanceGeneric(raw, rawReturn, &datacapv15.DecreaseAllowanceParams{}) -} - -// Revoke Allowance - -func revokeAllowanceExportedv9(raw, rawReturn []byte) (map[string]interface{}, error) { - return allowanceGeneric(raw, rawReturn, &datacapv9.RevokeAllowanceParams{}) -} - -func revokeAllowanceExportedv10(raw, rawReturn []byte) (map[string]interface{}, error) { - return allowanceGeneric(raw, rawReturn, &datacapv10.RevokeAllowanceParams{}) -} - -func revokeAllowanceExportedv11(raw, rawReturn []byte) (map[string]interface{}, error) { - return allowanceGeneric(raw, rawReturn, &datacapv11.RevokeAllowanceParams{}) -} - -func revokeAllowanceExportedv12(raw, rawReturn []byte) (map[string]interface{}, error) { - return allowanceGeneric(raw, rawReturn, &datacapv12.RevokeAllowanceParams{}) -} - -func revokeAllowanceExportedv13(raw, rawReturn []byte) (map[string]interface{}, error) { - return allowanceGeneric(raw, rawReturn, &datacapv13.RevokeAllowanceParams{}) -} - -func revokeAllowanceExportedv14(raw, rawReturn []byte) (map[string]interface{}, error) { - return allowanceGeneric(raw, rawReturn, &datacapv14.RevokeAllowanceParams{}) -} - -func revokeAllowanceExportedv15(raw, rawReturn []byte) (map[string]interface{}, error) { - return allowanceGeneric(raw, rawReturn, &datacapv15.RevokeAllowanceParams{}) -} - -// Get Allowance - -func allowanceExportedv9(raw, rawReturn []byte) (map[string]interface{}, error) { - return allowanceGeneric(raw, rawReturn, &datacapv9.GetAllowanceParams{}) -} - -func allowanceExportedv10(raw, rawReturn []byte) (map[string]interface{}, error) { - return allowanceGeneric(raw, rawReturn, &datacapv10.GetAllowanceParams{}) -} - -func allowanceExportedv11(raw, rawReturn []byte) (map[string]interface{}, error) { - return allowanceGeneric(raw, rawReturn, &datacapv11.GetAllowanceParams{}) -} - -func allowanceExportedv12(raw, rawReturn []byte) (map[string]interface{}, error) { - return allowanceGeneric(raw, rawReturn, &datacapv12.GetAllowanceParams{}) -} - -func allowanceExportedv13(raw, rawReturn []byte) (map[string]interface{}, error) { - return allowanceGeneric(raw, rawReturn, &datacapv13.GetAllowanceParams{}) -} - -func allowanceExportedv14(raw, rawReturn []byte) (map[string]interface{}, error) { - return allowanceGeneric(raw, rawReturn, &datacapv14.GetAllowanceParams{}) -} - -func allowanceExportedv15(raw, rawReturn []byte) (map[string]interface{}, error) { - return allowanceGeneric(raw, rawReturn, &datacapv15.GetAllowanceParams{}) -} diff --git a/actors/datacap/burn.go b/actors/datacap/burn.go index fc6648e1..511ab082 100644 --- a/actors/datacap/burn.go +++ b/actors/datacap/burn.go @@ -3,6 +3,7 @@ package datacap import ( "bytes" "fmt" + "io" datacapv10 "github.com/filecoin-project/go-state-types/builtin/v10/datacap" datacapv11 "github.com/filecoin-project/go-state-types/builtin/v11/datacap" @@ -10,31 +11,48 @@ import ( datacapv13 "github.com/filecoin-project/go-state-types/builtin/v13/datacap" datacapv14 "github.com/filecoin-project/go-state-types/builtin/v14/datacap" datacapv15 "github.com/filecoin-project/go-state-types/builtin/v15/datacap" - "github.com/filecoin-project/go-state-types/builtin/v9/datacap" datacapv9 "github.com/filecoin-project/go-state-types/builtin/v9/datacap" "github.com/zondax/fil-parser/parser" ) -type ( - burnParams = unmarshalCBOR - burnReturn = unmarshalCBOR - destroyParams = unmarshalCBOR - burnFromParams = unmarshalCBOR - burnFromReturn = unmarshalCBOR -) +type burnParams interface { + UnmarshalCBOR(r io.Reader) error +} + +type burnReturn interface { + UnmarshalCBOR(r io.Reader) error +} + +func burnGeneric[P unmarshalCBOR, R unmarshalCBOR](raw []byte, rawReturn []byte, params P, r R) (map[string]interface{}, error) { + metadata := make(map[string]interface{}) + reader := bytes.NewReader(raw) + err := params.UnmarshalCBOR(reader) + if err != nil { + return metadata, err + } + metadata[parser.ParamsKey] = params + + reader = bytes.NewReader(rawReturn) + err = r.UnmarshalCBOR(reader) + if err != nil { + return metadata, err + } + metadata[parser.ReturnKey] = r + return metadata, nil +} func BurnExported(height uint64, raw, rawReturn []byte) (map[string]interface{}, error) { switch height { case 9: - return burnExportedv9(raw, rawReturn) + return burnGeneric[*datacapv9.BurnParams, *datacapv9.BurnReturn](raw, rawReturn, &datacapv9.BurnParams{}, &datacapv9.BurnReturn{}) case 10: - return burnExportedv10(raw, rawReturn) + return burnGeneric[*datacapv10.BurnParams, *datacapv10.BurnReturn](raw, rawReturn, &datacapv10.BurnParams{}, &datacapv10.BurnReturn{}) case 11: - return burnExportedv11(raw, rawReturn) + return burnGeneric[*datacapv11.BurnParams, *datacapv11.BurnReturn](raw, rawReturn, &datacapv11.BurnParams{}, &datacapv11.BurnReturn{}) case 14: - return burnExportedv14(raw, rawReturn) + return burnGeneric[*datacapv14.BurnParams, *datacapv14.BurnReturn](raw, rawReturn, &datacapv14.BurnParams{}, &datacapv14.BurnReturn{}) case 15: - return burnExportedv15(raw, rawReturn) + return burnGeneric[*datacapv15.BurnParams, *datacapv15.BurnReturn](raw, rawReturn, &datacapv15.BurnParams{}, &datacapv15.BurnReturn{}) } return nil, fmt.Errorf("not supported") } @@ -42,19 +60,19 @@ func BurnExported(height uint64, raw, rawReturn []byte) (map[string]interface{}, func BurnFromExported(height uint64, raw, rawReturn []byte) (map[string]interface{}, error) { switch height { case 9: - return burnFromExportedv9(raw, rawReturn) + return burnGeneric[*datacapv9.BurnFromParams, *datacapv9.BurnFromReturn](raw, rawReturn, &datacapv9.BurnFromParams{}, &datacapv9.BurnFromReturn{}) case 10: - return burnFromExportedv10(raw, rawReturn) + return burnGeneric[*datacapv10.BurnFromParams, *datacapv10.BurnFromReturn](raw, rawReturn, &datacapv10.BurnFromParams{}, &datacapv10.BurnFromReturn{}) case 11: - return burnFromExportedv11(raw, rawReturn) + return burnGeneric[*datacapv11.BurnFromParams, *datacapv11.BurnFromReturn](raw, rawReturn, &datacapv11.BurnFromParams{}, &datacapv11.BurnFromReturn{}) case 12: - return burnFromExportedv12(raw, rawReturn) + return burnGeneric[*datacapv12.BurnFromParams, *datacapv12.BurnFromReturn](raw, rawReturn, &datacapv12.BurnFromParams{}, &datacapv12.BurnFromReturn{}) case 13: - return burnFromExportedv13(raw, rawReturn) + return burnGeneric[*datacapv13.BurnFromParams, *datacapv13.BurnFromReturn](raw, rawReturn, &datacapv13.BurnFromParams{}, &datacapv13.BurnFromReturn{}) case 14: - return burnFromExportedv14(raw, rawReturn) + return burnGeneric[*datacapv14.BurnFromParams, *datacapv14.BurnFromReturn](raw, rawReturn, &datacapv14.BurnFromParams{}, &datacapv14.BurnFromReturn{}) case 15: - return burnFromExportedv15(raw, rawReturn) + return burnGeneric[*datacapv15.BurnFromParams, *datacapv15.BurnFromReturn](raw, rawReturn, &datacapv15.BurnFromParams{}, &datacapv15.BurnFromReturn{}) } return nil, fmt.Errorf("not supported") } @@ -62,127 +80,19 @@ func BurnFromExported(height uint64, raw, rawReturn []byte) (map[string]interfac func DestroyExported(height uint64, raw, rawReturn []byte) (map[string]interface{}, error) { switch height { case 9: - return destroyExportedv9(raw, rawReturn) + return burnGeneric[*datacapv9.DestroyParams, *datacapv9.BurnReturn](raw, rawReturn, &datacapv9.DestroyParams{}, &datacapv9.BurnReturn{}) case 10: - return destroyExportedv10(raw, rawReturn) + return burnGeneric[*datacapv10.DestroyParams, *datacapv10.BurnReturn](raw, rawReturn, &datacapv10.DestroyParams{}, &datacapv10.BurnReturn{}) case 11: - return destroyExportedv11(raw, rawReturn) + return burnGeneric[*datacapv11.DestroyParams, *datacapv11.BurnReturn](raw, rawReturn, &datacapv11.DestroyParams{}, &datacapv11.BurnReturn{}) case 12: - return destroyExportedv12(raw, rawReturn) + return burnGeneric[*datacapv12.DestroyParams, *datacapv12.BurnReturn](raw, rawReturn, &datacapv12.DestroyParams{}, &datacapv12.BurnReturn{}) case 13: - return destroyExportedv13(raw, rawReturn) + return burnGeneric[*datacapv13.DestroyParams, *datacapv13.BurnReturn](raw, rawReturn, &datacapv13.DestroyParams{}, &datacapv13.BurnReturn{}) case 14: - return destroyExportedv14(raw, rawReturn) + return burnGeneric[*datacapv14.DestroyParams, *datacapv14.BurnReturn](raw, rawReturn, &datacapv14.DestroyParams{}, &datacapv14.BurnReturn{}) case 15: - return destroyExportedv15(raw, rawReturn) + return burnGeneric[*datacapv15.DestroyParams, *datacapv15.BurnReturn](raw, rawReturn, &datacapv15.DestroyParams{}, &datacapv15.BurnReturn{}) } return nil, fmt.Errorf("not supported") } - -func burnGeneric[P unmarshalCBOR, R unmarshalCBOR](raw []byte, rawReturn []byte, params P, r R) (map[string]interface{}, error) { - metadata := make(map[string]interface{}) - reader := bytes.NewReader(raw) - err := params.UnmarshalCBOR(reader) - if err != nil { - return metadata, err - } - metadata[parser.ParamsKey] = params - - reader = bytes.NewReader(rawReturn) - err = r.UnmarshalCBOR(reader) - if err != nil { - return metadata, err - } - metadata[parser.ReturnKey] = r - return metadata, nil -} - -// Burn Exported - -func burnExportedv9(raw, rawReturn []byte) (map[string]interface{}, error) { - return burnGeneric(raw, rawReturn, &datacapv9.BurnParams{}, &datacapv9.BurnReturn{}) -} - -func burnExportedv10(raw, rawReturn []byte) (map[string]interface{}, error) { - return burnGeneric(raw, rawReturn, &datacapv10.BurnParams{}, &datacapv10.BurnReturn{}) -} - -func burnExportedv11(raw, rawReturn []byte) (map[string]interface{}, error) { - return burnGeneric(raw, rawReturn, &datacapv11.BurnParams{}, &datacapv11.BurnReturn{}) -} - -func burnExportedv12(raw, rawReturn []byte) (map[string]interface{}, error) { - return burnGeneric(raw, rawReturn, &datacapv12.BurnParams{}, &datacapv12.BurnReturn{}) -} - -func burnExportedv13(raw, rawReturn []byte) (map[string]interface{}, error) { - return burnGeneric(raw, rawReturn, &datacapv13.BurnParams{}, &datacapv13.BurnReturn{}) -} - -func burnExportedv14(raw, rawReturn []byte) (map[string]interface{}, error) { - return burnGeneric(raw, rawReturn, &datacapv14.BurnParams{}, &datacapv14.BurnReturn{}) -} - -func burnExportedv15(raw, rawReturn []byte) (map[string]interface{}, error) { - return burnGeneric(raw, rawReturn, &datacapv15.BurnParams{}, &datacapv15.BurnReturn{}) -} - -// Destroy Exported - -func destroyExportedv9(raw, rawReturn []byte) (map[string]interface{}, error) { - return burnGeneric(raw, rawReturn, &datacapv9.DestroyParams{}, &datacapv9.BurnReturn{}) -} - -func destroyExportedv10(raw, rawReturn []byte) (map[string]interface{}, error) { - return burnGeneric(raw, rawReturn, &datacapv10.DestroyParams{}, &datacapv10.BurnReturn{}) -} - -func destroyExportedv11(raw, rawReturn []byte) (map[string]interface{}, error) { - return burnGeneric(raw, rawReturn, &datacap.DestroyParams{}, &datacap.BurnReturn{}) -} - -func destroyExportedv12(raw, rawReturn []byte) (map[string]interface{}, error) { - return burnGeneric(raw, rawReturn, &datacapv12.DestroyParams{}, &datacapv12.BurnReturn{}) -} - -func destroyExportedv13(raw, rawReturn []byte) (map[string]interface{}, error) { - return burnGeneric(raw, rawReturn, &datacapv13.DestroyParams{}, &datacapv13.BurnReturn{}) -} - -func destroyExportedv14(raw, rawReturn []byte) (map[string]interface{}, error) { - return burnGeneric(raw, rawReturn, &datacapv14.DestroyParams{}, &datacapv14.BurnReturn{}) -} - -func destroyExportedv15(raw, rawReturn []byte) (map[string]interface{}, error) { - return burnGeneric(raw, rawReturn, &datacapv15.DestroyParams{}, &datacapv15.BurnReturn{}) -} - -// Burn From Exported - -func burnFromExportedv9(raw, rawReturn []byte) (map[string]interface{}, error) { - return burnGeneric(raw, rawReturn, &datacapv9.BurnFromParams{}, &datacapv9.BurnFromReturn{}) -} - -func burnFromExportedv10(raw, rawReturn []byte) (map[string]interface{}, error) { - return burnGeneric(raw, rawReturn, &datacapv10.BurnFromParams{}, &datacapv10.BurnFromReturn{}) -} - -func burnFromExportedv11(raw, rawReturn []byte) (map[string]interface{}, error) { - return burnGeneric(raw, rawReturn, &datacapv11.BurnFromParams{}, &datacapv11.BurnFromReturn{}) -} - -func burnFromExportedv12(raw, rawReturn []byte) (map[string]interface{}, error) { - return burnGeneric(raw, rawReturn, &datacapv12.BurnFromParams{}, &datacapv12.BurnFromReturn{}) -} - -func burnFromExportedv13(raw, rawReturn []byte) (map[string]interface{}, error) { - return burnGeneric(raw, rawReturn, &datacapv13.BurnFromParams{}, &datacapv13.BurnFromReturn{}) -} - -func burnFromExportedv14(raw, rawReturn []byte) (map[string]interface{}, error) { - return burnGeneric(raw, rawReturn, &datacapv14.BurnFromParams{}, &datacapv14.BurnFromReturn{}) -} - -func burnFromExportedv15(raw, rawReturn []byte) (map[string]interface{}, error) { - return burnGeneric(raw, rawReturn, &datacapv15.BurnFromParams{}, &datacapv15.BurnFromReturn{}) -} diff --git a/actors/datacap/granularity.go b/actors/datacap/granularity.go index 11fb1145..d7584e59 100644 --- a/actors/datacap/granularity.go +++ b/actors/datacap/granularity.go @@ -15,65 +15,39 @@ import ( type granularityReturn = unmarshalCBOR +func granularityGeneric[T granularityReturn](rawReturn []byte, r T) (map[string]interface{}, error) { + metadata := make(map[string]interface{}) + reader := bytes.NewReader(rawReturn) + err := r.UnmarshalCBOR(reader) + if err != nil { + return metadata, err + } + metadata[parser.ReturnKey] = r + return metadata, nil +} + func GranularityExported(height uint64, rawReturn []byte) (map[string]interface{}, error) { switch height { case 9: return nil, fmt.Errorf("not supported") case 10: - return granularityExportedv10(rawReturn) + var r datacapv10.GranularityReturn + return granularityGeneric[*datacapv10.GranularityReturn](rawReturn, &r) case 11: - return granularityExportedv11(rawReturn) + var r datacapv11.GranularityReturn + return granularityGeneric[*datacapv11.GranularityReturn](rawReturn, &r) case 12: - return granularityExportedv12(rawReturn) + var r datacapv12.GranularityReturn + return granularityGeneric[*datacapv12.GranularityReturn](rawReturn, &r) case 13: - return granularityExportedv13(rawReturn) + var r datacapv13.GranularityReturn + return granularityGeneric[*datacapv13.GranularityReturn](rawReturn, &r) case 14: - return granularityExportedv14(rawReturn) + var r datacapv14.GranularityReturn + return granularityGeneric[*datacapv14.GranularityReturn](rawReturn, &r) case 15: - return granularityExportedv15(rawReturn) + var r datacapv15.GranularityReturn + return granularityGeneric[*datacapv15.GranularityReturn](rawReturn, &r) } return nil, fmt.Errorf("not supported") } - -func granularityGeneric[T granularityReturn](rawReturn []byte, r T) (map[string]interface{}, error) { - metadata := make(map[string]interface{}) - reader := bytes.NewReader(rawReturn) - err := r.UnmarshalCBOR(reader) - if err != nil { - return metadata, err - } - metadata[parser.ReturnKey] = r - return metadata, nil -} - -// Granularity Exported - -func granularityExportedv10(rawReturn []byte) (map[string]interface{}, error) { - var r datacapv10.GranularityReturn - return granularityGeneric[*datacapv10.GranularityReturn](rawReturn, &r) -} - -func granularityExportedv11(rawReturn []byte) (map[string]interface{}, error) { - var r datacapv11.GranularityReturn - return granularityGeneric[*datacapv11.GranularityReturn](rawReturn, &r) -} - -func granularityExportedv12(rawReturn []byte) (map[string]interface{}, error) { - var r datacapv12.GranularityReturn - return granularityGeneric[*datacapv12.GranularityReturn](rawReturn, &r) -} - -func granularityExportedv13(rawReturn []byte) (map[string]interface{}, error) { - var r datacapv13.GranularityReturn - return granularityGeneric[*datacapv13.GranularityReturn](rawReturn, &r) -} - -func granularityExportedv14(rawReturn []byte) (map[string]interface{}, error) { - var r datacapv14.GranularityReturn - return granularityGeneric[*datacapv14.GranularityReturn](rawReturn, &r) -} - -func granularityExportedv15(rawReturn []byte) (map[string]interface{}, error) { - var r datacapv15.GranularityReturn - return granularityGeneric[*datacapv15.GranularityReturn](rawReturn, &r) -} diff --git a/actors/datacap/mint.go b/actors/datacap/mint.go index 6cfe9003..f31b60e7 100644 --- a/actors/datacap/mint.go +++ b/actors/datacap/mint.go @@ -19,26 +19,6 @@ type ( mintReturn = unmarshalCBOR ) -func MintExported(height uint64, raw, rawReturn []byte) (map[string]interface{}, error) { - switch height { - case 9: - return mintExportedv9(raw, rawReturn) - case 10: - return mintExportedv10(raw, rawReturn) - case 11: - return mintExportedv11(raw, rawReturn) - case 12: - return mintExportedv12(raw, rawReturn) - case 13: - return mintExportedv13(raw, rawReturn) - case 14: - return mintExportedv14(raw, rawReturn) - case 15: - return mintExportedv15(raw, rawReturn) - } - return nil, fmt.Errorf("not supported") -} - func mintGeneric[P mintParams, R mintReturn](raw, rawReturn []byte, params P, r R) (map[string]interface{}, error) { metadata := make(map[string]interface{}) reader := bytes.NewReader(raw) @@ -57,30 +37,29 @@ func mintGeneric[P mintParams, R mintReturn](raw, rawReturn []byte, params P, r return metadata, nil } -func mintExportedv9(raw, rawReturn []byte) (map[string]interface{}, error) { - return mintGeneric[*datacapv9.MintParams, *datacapv9.MintReturn](raw, rawReturn, &datacapv9.MintParams{}, &datacapv9.MintReturn{}) -} - -func mintExportedv10(raw, rawReturn []byte) (map[string]interface{}, error) { - return mintGeneric[*datacapv10.MintParams, *datacapv10.MintReturn](raw, rawReturn, &datacapv10.MintParams{}, &datacapv10.MintReturn{}) -} - -func mintExportedv11(raw, rawReturn []byte) (map[string]interface{}, error) { - return mintGeneric[*datacapv11.MintParams, *datacapv11.MintReturn](raw, rawReturn, &datacapv11.MintParams{}, &datacapv11.MintReturn{}) -} - -func mintExportedv12(raw, rawReturn []byte) (map[string]interface{}, error) { - return mintGeneric[*datacapv12.MintParams, *datacapv12.MintReturn](raw, rawReturn, &datacapv12.MintParams{}, &datacapv12.MintReturn{}) -} - -func mintExportedv13(raw, rawReturn []byte) (map[string]interface{}, error) { - return mintGeneric[*datacapv13.MintParams, *datacapv13.MintReturn](raw, rawReturn, &datacapv13.MintParams{}, &datacapv13.MintReturn{}) -} - -func mintExportedv14(raw, rawReturn []byte) (map[string]interface{}, error) { - return mintGeneric[*datacapv14.MintParams, *datacapv14.MintReturn](raw, rawReturn, &datacapv14.MintParams{}, &datacapv14.MintReturn{}) -} - -func mintExportedv15(raw, rawReturn []byte) (map[string]interface{}, error) { - return mintGeneric[*datacapv15.MintParams, *datacapv15.MintReturn](raw, rawReturn, &datacapv15.MintParams{}, &datacapv15.MintReturn{}) +func MintExported(height uint64, raw, rawReturn []byte) (map[string]interface{}, error) { + switch height { + case 9: + var r datacapv9.MintReturn + return mintGeneric[*datacapv9.MintParams, *datacapv9.MintReturn](raw, rawReturn, &datacapv9.MintParams{}, &r) + case 10: + var r datacapv10.MintReturn + return mintGeneric[*datacapv10.MintParams, *datacapv10.MintReturn](raw, rawReturn, &datacapv10.MintParams{}, &r) + case 11: + var r datacapv11.MintReturn + return mintGeneric[*datacapv11.MintParams, *datacapv11.MintReturn](raw, rawReturn, &datacapv11.MintParams{}, &r) + case 12: + var r datacapv12.MintReturn + return mintGeneric[*datacapv12.MintParams, *datacapv12.MintReturn](raw, rawReturn, &datacapv12.MintParams{}, &r) + case 13: + var r datacapv13.MintReturn + return mintGeneric[*datacapv13.MintParams, *datacapv13.MintReturn](raw, rawReturn, &datacapv13.MintParams{}, &r) + case 14: + var r datacapv14.MintReturn + return mintGeneric[*datacapv14.MintParams, *datacapv14.MintReturn](raw, rawReturn, &datacapv14.MintParams{}, &r) + case 15: + var r datacapv15.MintReturn + return mintGeneric[*datacapv15.MintParams, *datacapv15.MintReturn](raw, rawReturn, &datacapv15.MintParams{}, &r) + } + return nil, fmt.Errorf("not supported") } diff --git a/actors/datacap/transfer.go b/actors/datacap/transfer.go index 079ed3f7..a098fb62 100644 --- a/actors/datacap/transfer.go +++ b/actors/datacap/transfer.go @@ -14,41 +14,14 @@ import ( "github.com/zondax/fil-parser/parser" ) -type ( - transferParams = unmarshalCBOR - transferReturn = unmarshalCBOR - transferFromParams = unmarshalCBOR - transferFromReturn = unmarshalCBOR -) - -type transferParamsInterface interface { +type transferParams interface { unmarshalCBOR } -type transferReturnInterface interface { +type transferReturn interface { unmarshalCBOR } -func TransferExported(height uint64, raw, rawReturn []byte) (map[string]interface{}, error) { - switch height { - case 9: - return transferExportedv9(raw, rawReturn) - case 10: - return transferExportedv10(raw, rawReturn) - case 11: - return transferExportedv11(raw, rawReturn) - case 12: - return transferExportedv12(raw, rawReturn) - case 13: - return transferExportedv13(raw, rawReturn) - case 14: - return transferExportedv14(raw, rawReturn) - case 15: - return transferExportedv15(raw, rawReturn) - } - return nil, fmt.Errorf("not supported") -} - -func transferGeneric[P transferParamsInterface, R transferReturnInterface](raw, rawReturn []byte, params P, r R) (map[string]interface{}, error) { +func transferGeneric[P transferParams, R transferReturn](raw, rawReturn []byte, params P, r R) (map[string]interface{}, error) { metadata := make(map[string]interface{}) reader := bytes.NewReader(raw) err := params.UnmarshalCBOR(reader) @@ -66,30 +39,22 @@ func transferGeneric[P transferParamsInterface, R transferReturnInterface](raw, return metadata, nil } -func transferExportedv9(raw, rawReturn []byte) (map[string]interface{}, error) { - return transferGeneric[*datacapv9.TransferParams, *datacapv9.TransferReturn](raw, rawReturn, &datacapv9.TransferParams{}, &datacapv9.TransferReturn{}) -} - -func transferExportedv10(raw, rawReturn []byte) (map[string]interface{}, error) { - return transferGeneric[*datacapv10.TransferParams, *datacapv10.TransferReturn](raw, rawReturn, &datacapv10.TransferParams{}, &datacapv10.TransferReturn{}) -} - -func transferExportedv11(raw, rawReturn []byte) (map[string]interface{}, error) { - return transferGeneric[*datacapv11.TransferParams, *datacapv11.TransferReturn](raw, rawReturn, &datacapv11.TransferParams{}, &datacapv11.TransferReturn{}) -} - -func transferExportedv12(raw, rawReturn []byte) (map[string]interface{}, error) { - return transferGeneric[*datacapv12.TransferParams, *datacapv12.TransferReturn](raw, rawReturn, &datacapv12.TransferParams{}, &datacapv12.TransferReturn{}) -} - -func transferExportedv13(raw, rawReturn []byte) (map[string]interface{}, error) { - return transferGeneric[*datacapv13.TransferParams, *datacapv13.TransferReturn](raw, rawReturn, &datacapv13.TransferParams{}, &datacapv13.TransferReturn{}) -} - -func transferExportedv14(raw, rawReturn []byte) (map[string]interface{}, error) { - return transferGeneric[*datacapv14.TransferParams, *datacapv14.TransferReturn](raw, rawReturn, &datacapv14.TransferParams{}, &datacapv14.TransferReturn{}) -} - -func transferExportedv15(raw, rawReturn []byte) (map[string]interface{}, error) { - return transferGeneric[*datacapv15.TransferParams, *datacapv15.TransferReturn](raw, rawReturn, &datacapv15.TransferParams{}, &datacapv15.TransferReturn{}) +func TransferExported(height uint64, raw, rawReturn []byte) (map[string]interface{}, error) { + switch height { + case 9: + return transferGeneric[*datacapv9.TransferParams, *datacapv9.TransferReturn](raw, rawReturn, &datacapv9.TransferParams{}, &datacapv9.TransferReturn{}) + case 10: + return transferGeneric[*datacapv10.TransferParams, *datacapv10.TransferReturn](raw, rawReturn, &datacapv10.TransferParams{}, &datacapv10.TransferReturn{}) + case 11: + return transferGeneric[*datacapv11.TransferParams, *datacapv11.TransferReturn](raw, rawReturn, &datacapv11.TransferParams{}, &datacapv11.TransferReturn{}) + case 12: + return transferGeneric[*datacapv12.TransferParams, *datacapv12.TransferReturn](raw, rawReturn, &datacapv12.TransferParams{}, &datacapv12.TransferReturn{}) + case 13: + return transferGeneric[*datacapv13.TransferParams, *datacapv13.TransferReturn](raw, rawReturn, &datacapv13.TransferParams{}, &datacapv13.TransferReturn{}) + case 14: + return transferGeneric[*datacapv14.TransferParams, *datacapv14.TransferReturn](raw, rawReturn, &datacapv14.TransferParams{}, &datacapv14.TransferReturn{}) + case 15: + return transferGeneric[*datacapv15.TransferParams, *datacapv15.TransferReturn](raw, rawReturn, &datacapv15.TransferParams{}, &datacapv15.TransferReturn{}) + } + return nil, fmt.Errorf("not supported") } diff --git a/actors/eam/create.go b/actors/eam/create.go new file mode 100644 index 00000000..3afec030 --- /dev/null +++ b/actors/eam/create.go @@ -0,0 +1,78 @@ +package eam + +import ( + "fmt" + + eamv10 "github.com/filecoin-project/go-state-types/builtin/v10/eam" + eamv11 "github.com/filecoin-project/go-state-types/builtin/v11/eam" + eamv12 "github.com/filecoin-project/go-state-types/builtin/v12/eam" + eamv13 "github.com/filecoin-project/go-state-types/builtin/v13/eam" + eamv14 "github.com/filecoin-project/go-state-types/builtin/v14/eam" + eamv15 "github.com/filecoin-project/go-state-types/builtin/v15/eam" + eamv9 "github.com/filecoin-project/go-state-types/builtin/v9/eam" + "github.com/ipfs/go-cid" + "github.com/zondax/fil-parser/types" +) + +func ParseCreateExternal(height int64, rawParams, rawReturn []byte, msgCid cid.Cid) (map[string]interface{}, *types.AddressInfo, error) { + external := true + switch height { + case 15: + return parseCreate[*eamv15.CreateExternalReturn](rawParams, rawReturn, msgCid, external) + case 14: + return parseCreate[*eamv14.CreateExternalReturn](rawParams, rawReturn, msgCid, external) + case 13: + return parseCreate[*eamv13.CreateExternalReturn](rawParams, rawReturn, msgCid, external) + case 12: + return parseCreate[*eamv12.CreateExternalReturn](rawParams, rawReturn, msgCid, external) + case 11: + return parseCreate[*eamv11.CreateExternalReturn](rawParams, rawReturn, msgCid, external) + case 10: + return parseCreate[*eamv10.CreateExternalReturn](rawParams, rawReturn, msgCid, external) + case 9: + return parseCreate[*eamv9.CreateExternalReturn](rawParams, rawReturn, msgCid, external) + } + return nil, nil, fmt.Errorf("unsupported height: %d", height) +} + +func ParseCreate(height int64, rawParams, rawReturn []byte, msgCid cid.Cid) (map[string]interface{}, *types.AddressInfo, error) { + external := false + switch height { + case 15: + return parseCreate[*eamv15.CreateReturn](rawParams, rawReturn, msgCid, external) + case 14: + return parseCreate[*eamv14.CreateReturn](rawParams, rawReturn, msgCid, external) + case 13: + return parseCreate[*eamv13.CreateReturn](rawParams, rawReturn, msgCid, external) + case 12: + return parseCreate[*eamv12.CreateReturn](rawParams, rawReturn, msgCid, external) + case 11: + return parseCreate[*eamv11.CreateReturn](rawParams, rawReturn, msgCid, external) + case 10: + return parseCreate[*eamv10.CreateReturn](rawParams, rawReturn, msgCid, external) + case 9: + return parseCreate[*eamv9.CreateReturn](rawParams, rawReturn, msgCid, external) + } + return nil, nil, fmt.Errorf("unsupported height: %d", height) +} + +func ParseCreate2(height int64, rawParams, rawReturn []byte, msgCid cid.Cid) (map[string]interface{}, *types.AddressInfo, error) { + external := false + switch height { + case 15: + return parseCreate[*eamv15.Create2Return](rawParams, rawReturn, msgCid, external) + case 14: + return parseCreate[*eamv14.Create2Return](rawParams, rawReturn, msgCid, external) + case 13: + return parseCreate[*eamv13.Create2Return](rawParams, rawReturn, msgCid, external) + case 12: + return parseCreate[*eamv12.Create2Return](rawParams, rawReturn, msgCid, external) + case 11: + return parseCreate[*eamv11.Create2Return](rawParams, rawReturn, msgCid, external) + case 10: + return parseCreate[*eamv10.Create2Return](rawParams, rawReturn, msgCid, external) + case 9: + return parseCreate[*eamv9.Create2Return](rawParams, rawReturn, msgCid, external) + } + return nil, nil, fmt.Errorf("unsupported height: %d", height) +} diff --git a/actors/eam/eam.go b/actors/eam/eam.go new file mode 100644 index 00000000..7c6507e7 --- /dev/null +++ b/actors/eam/eam.go @@ -0,0 +1,99 @@ +package eam + +import ( + "encoding/hex" + "fmt" + + "github.com/filecoin-project/go-address" + eamv10 "github.com/filecoin-project/go-state-types/builtin/v10/eam" + eamv11 "github.com/filecoin-project/go-state-types/builtin/v11/eam" + eamv12 "github.com/filecoin-project/go-state-types/builtin/v12/eam" + eamv13 "github.com/filecoin-project/go-state-types/builtin/v13/eam" + eamv14 "github.com/filecoin-project/go-state-types/builtin/v14/eam" + eamv15 "github.com/filecoin-project/go-state-types/builtin/v15/eam" + eamv9 "github.com/filecoin-project/go-state-types/builtin/v9/eam" + "github.com/zondax/fil-parser/parser" +) + +func newEamCreate(r createReturn) parser.EamCreateReturn { + switch v := r.(type) { + case *eamv15.CreateReturn: + return parser.EamCreateReturn{ + ActorId: v.ActorID, + RobustAddress: v.RobustAddress, + EthAddress: parser.EthPrefix + hex.EncodeToString(v.EthAddress[:]), + } + case *eamv14.CreateReturn: + return parser.EamCreateReturn{ + ActorId: v.ActorID, + RobustAddress: v.RobustAddress, + EthAddress: parser.EthPrefix + hex.EncodeToString(v.EthAddress[:]), + } + case *eamv13.CreateReturn: + return parser.EamCreateReturn{ + ActorId: v.ActorID, + RobustAddress: v.RobustAddress, + EthAddress: parser.EthPrefix + hex.EncodeToString(v.EthAddress[:]), + } + case *eamv12.CreateReturn: + return parser.EamCreateReturn{ + ActorId: v.ActorID, + RobustAddress: v.RobustAddress, + EthAddress: parser.EthPrefix + hex.EncodeToString(v.EthAddress[:]), + } + case *eamv11.CreateReturn: + return parser.EamCreateReturn{ + ActorId: v.ActorID, + RobustAddress: v.RobustAddress, + EthAddress: parser.EthPrefix + hex.EncodeToString(v.EthAddress[:]), + } + case *eamv10.CreateReturn: + return parser.EamCreateReturn{ + ActorId: v.ActorID, + RobustAddress: v.RobustAddress, + EthAddress: parser.EthPrefix + hex.EncodeToString(v.EthAddress[:]), + } + case *eamv9.CreateReturn: + return parser.EamCreateReturn{ + ActorId: v.ActorID, + RobustAddress: v.RobustAddress, + EthAddress: parser.EthPrefix + hex.EncodeToString(v.EthAddress[:]), + } + default: + return parser.EamCreateReturn{} + } +} + +func validateEamReturn(ret createReturn) error { + if ret == nil { + return fmt.Errorf("input is nil") + } + + checkAndSetAddress := func(addr **address.Address) error { + if *addr == nil { + emptyAdd, _ := address.NewFromString("") + *addr = &emptyAdd + return fmt.Errorf("RobustAddress field is nil. Replaced with empty address") + } + return nil + } + + switch v := ret.(type) { + case *eamv15.CreateReturn: + return checkAndSetAddress(&v.RobustAddress) + case *eamv14.CreateReturn: + return checkAndSetAddress(&v.RobustAddress) + case *eamv13.CreateReturn: + return checkAndSetAddress(&v.RobustAddress) + case *eamv12.CreateReturn: + return checkAndSetAddress(&v.RobustAddress) + case *eamv11.CreateReturn: + return checkAndSetAddress(&v.RobustAddress) + case *eamv10.CreateReturn: + return checkAndSetAddress(&v.RobustAddress) + case *eamv9.CreateReturn: + return checkAndSetAddress(&v.RobustAddress) + } + + return nil +} diff --git a/actors/eam/generic.go b/actors/eam/generic.go new file mode 100644 index 00000000..5aef53a9 --- /dev/null +++ b/actors/eam/generic.go @@ -0,0 +1,78 @@ +package eam + +import ( + "bytes" + "encoding/hex" + "fmt" + "strconv" + + "github.com/filecoin-project/go-state-types/abi" + "github.com/filecoin-project/lotus/chain/types/ethtypes" + "github.com/ipfs/go-cid" + "github.com/zondax/fil-parser/parser" + "github.com/zondax/fil-parser/types" +) + +func parseEamReturn[R createReturn](rawReturn []byte) (R, error) { + var cr R + + reader := bytes.NewReader(rawReturn) + err := cr.UnmarshalCBOR(reader) + if err != nil { + return cr, err + } + + err = validateEamReturn(cr) + if err != nil { + rawString := hex.EncodeToString(rawReturn) + return cr, fmt.Errorf("[parseEamReturn]- Detected invalid return bytes: %s. Raw: %s", err, rawString) + } + + return cr, nil +} + +func parseCreate[T createReturn](rawParams, rawReturn []byte, msgCid cid.Cid, isExternal bool) (map[string]interface{}, *types.AddressInfo, error) { + metadata := make(map[string]interface{}) + reader := bytes.NewReader(rawParams) + + if isExternal { + metadata[parser.ParamsKey] = parser.EthPrefix + hex.EncodeToString(rawParams) + var params abi.CborBytes + if err := params.UnmarshalCBOR(reader); err != nil { + return metadata, nil, fmt.Errorf("error deserializing rawParams: %s - hex data: %s", err.Error(), hex.EncodeToString(rawParams)) + } + + if reader.Len() == 0 { // This means that the reader has processed all the bytes + metadata[parser.ParamsKey] = parser.EthPrefix + hex.EncodeToString(params) + } + } else { + var params T + err := params.UnmarshalCBOR(reader) + if err != nil { + return metadata, nil, err + } + } + + createReturn, err := parseEamReturn[T](rawReturn) + if err != nil { + return metadata, nil, err + } + + metadata[parser.ReturnKey] = newEamCreate(createReturn) + + ethHash, err := ethtypes.EthHashFromCid(msgCid) + if err != nil { + return metadata, nil, err + } + metadata[parser.EthHashKey] = ethHash.String() + + r := newEamCreate(createReturn) + createdEvmActor := &types.AddressInfo{ + Short: parser.FilPrefix + strconv.FormatUint(r.ActorId, 10), + Robust: r.RobustAddress.String(), + EthAddress: parser.EthPrefix + r.EthAddress, + ActorType: "evm", + CreationTxCid: msgCid.String(), + } + return metadata, createdEvmActor, nil +} diff --git a/actors/eam/return.go b/actors/eam/return.go deleted file mode 100644 index 6280e813..00000000 --- a/actors/eam/return.go +++ /dev/null @@ -1,261 +0,0 @@ -package eam - -import ( - "bytes" - "encoding/hex" - "fmt" - "io" - "strconv" - - "github.com/filecoin-project/go-address" - "github.com/filecoin-project/go-state-types/abi" - eamv10 "github.com/filecoin-project/go-state-types/builtin/v10/eam" - eamv11 "github.com/filecoin-project/go-state-types/builtin/v11/eam" - eamv12 "github.com/filecoin-project/go-state-types/builtin/v12/eam" - eamv13 "github.com/filecoin-project/go-state-types/builtin/v13/eam" - eamv14 "github.com/filecoin-project/go-state-types/builtin/v14/eam" - eamv15 "github.com/filecoin-project/go-state-types/builtin/v15/eam" - eamv9 "github.com/filecoin-project/go-state-types/builtin/v9/eam" - "github.com/filecoin-project/lotus/chain/types/ethtypes" - "github.com/ipfs/go-cid" - "github.com/zondax/fil-parser/parser" - "github.com/zondax/fil-parser/types" -) - -type createReturn interface { - UnmarshalCBOR(io.Reader) error -} - -type createReturnStruct[T any] struct { - CreateReturn T -} - -func parseEamReturn[R createReturn](rawReturn []byte) (R, error) { - var cr R - - reader := bytes.NewReader(rawReturn) - err := cr.UnmarshalCBOR(reader) - if err != nil { - return cr, err - } - - err = validateEamReturn(cr) - if err != nil { - rawString := hex.EncodeToString(rawReturn) - return cr, fmt.Errorf("[parseEamReturn]- Detected invalid return bytes: %s. Raw: %s", err, rawString) - } - - return cr, nil -} - -func ParseEamReturn(height int64, rawReturn []byte) (any, error) { - switch height { - case 15: - return parseEamReturn[*eamv15.CreateReturn](rawReturn) - case 14: - return parseEamReturn[*eamv14.CreateReturn](rawReturn) - case 13: - return parseEamReturn[*eamv13.CreateReturn](rawReturn) - case 12: - return parseEamReturn[*eamv12.CreateReturn](rawReturn) - case 11: - return parseEamReturn[*eamv11.CreateReturn](rawReturn) - case 10: - return parseEamReturn[*eamv10.CreateReturn](rawReturn) - case 9: - return parseEamReturn[*eamv9.CreateReturn](rawReturn) - } - return nil, fmt.Errorf("unsupported height: %d", height) -} - -func ParseCreateExternal(height int64, rawParams, rawReturn []byte, msgCid cid.Cid) (map[string]interface{}, *types.AddressInfo, error) { - external := true - switch height { - case 15: - return parseCreate[*eamv15.CreateExternalReturn](rawParams, rawReturn, msgCid, external) - case 14: - return parseCreate[*eamv14.CreateExternalReturn](rawParams, rawReturn, msgCid, external) - case 13: - return parseCreate[*eamv13.CreateExternalReturn](rawParams, rawReturn, msgCid, external) - case 12: - return parseCreate[*eamv12.CreateExternalReturn](rawParams, rawReturn, msgCid, external) - case 11: - return parseCreate[*eamv11.CreateExternalReturn](rawParams, rawReturn, msgCid, external) - case 10: - return parseCreate[*eamv10.CreateExternalReturn](rawParams, rawReturn, msgCid, external) - case 9: - return parseCreate[*eamv9.CreateExternalReturn](rawParams, rawReturn, msgCid, external) - } - return nil, nil, fmt.Errorf("unsupported height: %d", height) -} - -func ParseCreate(height int64, rawParams, rawReturn []byte, msgCid cid.Cid) (map[string]interface{}, *types.AddressInfo, error) { - external := false - switch height { - case 15: - return parseCreate[*eamv15.CreateReturn](rawParams, rawReturn, msgCid, external) - case 14: - return parseCreate[*eamv14.CreateReturn](rawParams, rawReturn, msgCid, external) - case 13: - return parseCreate[*eamv13.CreateReturn](rawParams, rawReturn, msgCid, external) - case 12: - return parseCreate[*eamv12.CreateReturn](rawParams, rawReturn, msgCid, external) - case 11: - return parseCreate[*eamv11.CreateReturn](rawParams, rawReturn, msgCid, external) - case 10: - return parseCreate[*eamv10.CreateReturn](rawParams, rawReturn, msgCid, external) - case 9: - return parseCreate[*eamv9.CreateReturn](rawParams, rawReturn, msgCid, external) - } - return nil, nil, fmt.Errorf("unsupported height: %d", height) -} - -func ParseCreate2(height int64, rawParams, rawReturn []byte, msgCid cid.Cid) (map[string]interface{}, *types.AddressInfo, error) { - external := false - switch height { - case 15: - return parseCreate[*eamv15.Create2Return](rawParams, rawReturn, msgCid, external) - case 14: - return parseCreate[*eamv14.Create2Return](rawParams, rawReturn, msgCid, external) - case 13: - return parseCreate[*eamv13.Create2Return](rawParams, rawReturn, msgCid, external) - case 12: - return parseCreate[*eamv12.Create2Return](rawParams, rawReturn, msgCid, external) - case 11: - return parseCreate[*eamv11.Create2Return](rawParams, rawReturn, msgCid, external) - case 10: - return parseCreate[*eamv10.Create2Return](rawParams, rawReturn, msgCid, external) - case 9: - return parseCreate[*eamv9.Create2Return](rawParams, rawReturn, msgCid, external) - } - return nil, nil, fmt.Errorf("unsupported height: %d", height) -} - -func newEamCreate(r createReturn) parser.EamCreateReturn { - switch v := r.(type) { - case *eamv15.CreateReturn: - return parser.EamCreateReturn{ - ActorId: v.ActorID, - RobustAddress: v.RobustAddress, - EthAddress: parser.EthPrefix + hex.EncodeToString(v.EthAddress[:]), - } - case *eamv14.CreateReturn: - return parser.EamCreateReturn{ - ActorId: v.ActorID, - RobustAddress: v.RobustAddress, - EthAddress: parser.EthPrefix + hex.EncodeToString(v.EthAddress[:]), - } - case *eamv13.CreateReturn: - return parser.EamCreateReturn{ - ActorId: v.ActorID, - RobustAddress: v.RobustAddress, - EthAddress: parser.EthPrefix + hex.EncodeToString(v.EthAddress[:]), - } - case *eamv12.CreateReturn: - return parser.EamCreateReturn{ - ActorId: v.ActorID, - RobustAddress: v.RobustAddress, - EthAddress: parser.EthPrefix + hex.EncodeToString(v.EthAddress[:]), - } - case *eamv11.CreateReturn: - return parser.EamCreateReturn{ - ActorId: v.ActorID, - RobustAddress: v.RobustAddress, - EthAddress: parser.EthPrefix + hex.EncodeToString(v.EthAddress[:]), - } - case *eamv10.CreateReturn: - return parser.EamCreateReturn{ - ActorId: v.ActorID, - RobustAddress: v.RobustAddress, - EthAddress: parser.EthPrefix + hex.EncodeToString(v.EthAddress[:]), - } - case *eamv9.CreateReturn: - return parser.EamCreateReturn{ - ActorId: v.ActorID, - RobustAddress: v.RobustAddress, - EthAddress: parser.EthPrefix + hex.EncodeToString(v.EthAddress[:]), - } - default: - return parser.EamCreateReturn{} - } -} - -func validateEamReturn(ret createReturn) error { - if ret == nil { - return fmt.Errorf("input is nil") - } - - checkAndSetAddress := func(addr **address.Address) error { - if *addr == nil { - emptyAdd, _ := address.NewFromString("") - *addr = &emptyAdd - return fmt.Errorf("RobustAddress field is nil. Replaced with empty address") - } - return nil - } - - switch v := ret.(type) { - case *eamv15.CreateReturn: - return checkAndSetAddress(&v.RobustAddress) - case *eamv14.CreateReturn: - return checkAndSetAddress(&v.RobustAddress) - case *eamv13.CreateReturn: - return checkAndSetAddress(&v.RobustAddress) - case *eamv12.CreateReturn: - return checkAndSetAddress(&v.RobustAddress) - case *eamv11.CreateReturn: - return checkAndSetAddress(&v.RobustAddress) - case *eamv10.CreateReturn: - return checkAndSetAddress(&v.RobustAddress) - case *eamv9.CreateReturn: - return checkAndSetAddress(&v.RobustAddress) - } - - return nil -} - -func parseCreate[T createReturn](rawParams, rawReturn []byte, msgCid cid.Cid, isExternal bool) (map[string]interface{}, *types.AddressInfo, error) { - metadata := make(map[string]interface{}) - reader := bytes.NewReader(rawParams) - - if isExternal { - metadata[parser.ParamsKey] = parser.EthPrefix + hex.EncodeToString(rawParams) - var params abi.CborBytes - if err := params.UnmarshalCBOR(reader); err != nil { - return metadata, nil, fmt.Errorf("error deserializing rawParams: %s - hex data: %s", err.Error(), hex.EncodeToString(rawParams)) - } - - if reader.Len() == 0 { // This means that the reader has processed all the bytes - metadata[parser.ParamsKey] = parser.EthPrefix + hex.EncodeToString(params) - } - } else { - var params T - err := params.UnmarshalCBOR(reader) - if err != nil { - return metadata, nil, err - } - } - - createReturn, err := parseEamReturn[T](rawReturn) - if err != nil { - return metadata, nil, err - } - - metadata[parser.ReturnKey] = newEamCreate(createReturn) - - ethHash, err := ethtypes.EthHashFromCid(msgCid) - if err != nil { - return metadata, nil, err - } - metadata[parser.EthHashKey] = ethHash.String() - - r := newEamCreate(createReturn) - createdEvmActor := &types.AddressInfo{ - Short: parser.FilPrefix + strconv.FormatUint(r.ActorId, 10), - Robust: r.RobustAddress.String(), - EthAddress: parser.EthPrefix + r.EthAddress, - ActorType: "evm", - CreationTxCid: msgCid.String(), - } - return metadata, createdEvmActor, nil -} diff --git a/actors/eam/types.go b/actors/eam/types.go new file mode 100644 index 00000000..86b6084a --- /dev/null +++ b/actors/eam/types.go @@ -0,0 +1,7 @@ +package eam + +import "io" + +type createReturn interface { + UnmarshalCBOR(io.Reader) error +} diff --git a/actors/evm/evm.go b/actors/evm/evm.go index 505f25af..6eb68a89 100644 --- a/actors/evm/evm.go +++ b/actors/evm/evm.go @@ -4,7 +4,6 @@ import ( "bytes" "encoding/hex" "fmt" - "io" "github.com/filecoin-project/go-state-types/abi" evmv10 "github.com/filecoin-project/go-state-types/builtin/v10/evm" @@ -16,14 +15,6 @@ import ( "github.com/zondax/fil-parser/parser" ) -type evmParams interface { - UnmarshalCBOR(io.Reader) error -} - -type evmReturn interface { - UnmarshalCBOR(io.Reader) error -} - func InvokeContract(rawParams, rawReturn []byte) (map[string]interface{}, error) { metadata := make(map[string]interface{}) reader := bytes.NewReader(rawParams) @@ -55,17 +46,17 @@ func InvokeContract(rawParams, rawReturn []byte) (map[string]interface{}, error) func Resurrect(height int64, raw []byte) (map[string]interface{}, error) { switch height { case 15: - return getByteCode[*evmv15.ResurrectParams](parser.ParamsKey, raw) + return parse[*evmv15.ResurrectParams, *evmv15.ResurrectParams](raw, nil, false) case 14: - return getByteCode[*evmv14.ResurrectParams](parser.ParamsKey, raw) + return parse[*evmv14.ResurrectParams, *evmv14.ResurrectParams](raw, nil, false) case 13: - return getByteCode[*evmv13.ResurrectParams](parser.ParamsKey, raw) + return parse[*evmv13.ResurrectParams, *evmv13.ResurrectParams](raw, nil, false) case 12: - return getByteCode[*evmv12.ResurrectParams](parser.ParamsKey, raw) + return parse[*evmv12.ResurrectParams, *evmv12.ResurrectParams](raw, nil, false) case 11: - return getByteCode[*evmv11.ResurrectParams](parser.ParamsKey, raw) + return parse[*evmv11.ResurrectParams, *evmv11.ResurrectParams](raw, nil, false) case 10: - return getByteCode[*evmv10.ResurrectParams](parser.ParamsKey, raw) + return parse[*evmv10.ResurrectParams, *evmv10.ResurrectParams](raw, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) } @@ -73,17 +64,17 @@ func Resurrect(height int64, raw []byte) (map[string]interface{}, error) { func InvokeContractDelegate(height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { switch height { case 15: - return invokeContractDelegate[*evmv15.DelegateCallParams, *abi.CborBytes](rawParams, rawReturn) + return parse[*evmv15.DelegateCallParams, *abi.CborBytes](rawParams, rawReturn, true) case 14: - return invokeContractDelegate[*evmv14.DelegateCallParams, *abi.CborBytes](rawParams, rawReturn) + return parse[*evmv14.DelegateCallParams, *abi.CborBytes](rawParams, rawReturn, true) case 13: - return invokeContractDelegate[*evmv13.DelegateCallParams, *abi.CborBytes](rawParams, rawReturn) + return parse[*evmv13.DelegateCallParams, *abi.CborBytes](rawParams, rawReturn, true) case 12: - return invokeContractDelegate[*evmv12.DelegateCallParams, *abi.CborBytes](rawParams, rawReturn) + return parse[*evmv12.DelegateCallParams, *abi.CborBytes](rawParams, rawReturn, true) case 11: - return invokeContractDelegate[*evmv11.DelegateCallParams, *abi.CborBytes](rawParams, rawReturn) + return parse[*evmv11.DelegateCallParams, *abi.CborBytes](rawParams, rawReturn, true) case 10: - return invokeContractDelegate[*evmv10.DelegateCallParams, *abi.CborBytes](rawParams, rawReturn) + return parse[*evmv10.DelegateCallParams, *abi.CborBytes](rawParams, rawReturn, true) } return nil, fmt.Errorf("unsupported height: %d", height) } @@ -91,17 +82,45 @@ func InvokeContractDelegate(height int64, rawParams, rawReturn []byte) (map[stri func GetByteCode(height int64, raw []byte) (map[string]interface{}, error) { switch height { case 15: - return getByteCode[*evmv15.GetBytecodeReturn](parser.ReturnKey, raw) + data, err := parse[*evmv15.GetBytecodeReturn, *evmv15.GetBytecodeReturn](raw, nil, false) + if err != nil { + return nil, err + } + // The return value is the same as the params + data[parser.ReturnKey] = data[parser.ParamsKey] + return data, nil case 14: - return getByteCode[*evmv14.GetBytecodeReturn](parser.ReturnKey, raw) + data, err := parse[*evmv14.GetBytecodeReturn, *evmv14.GetBytecodeReturn](raw, nil, false) + if err != nil { + return nil, err + } + // The return value is the same as the params + data[parser.ReturnKey] = data[parser.ParamsKey] + return data, nil case 13: - return getByteCode[*evmv13.GetBytecodeReturn](parser.ReturnKey, raw) - case 12: - return getByteCode[*evmv12.GetBytecodeReturn](parser.ReturnKey, raw) + data, err := parse[*evmv13.GetBytecodeReturn, *evmv13.GetBytecodeReturn](raw, nil, false) + if err != nil { + return nil, err + } + // The return value is the same as the params + data[parser.ReturnKey] = data[parser.ParamsKey] + return data, nil case 11: - return getByteCode[*evmv11.GetBytecodeReturn](parser.ReturnKey, raw) + data, err := parse[*evmv11.GetBytecodeReturn, *evmv11.GetBytecodeReturn](raw, nil, false) + if err != nil { + return nil, err + } + // The return value is the same as the params + data[parser.ReturnKey] = data[parser.ParamsKey] + return data, nil case 10: - return getByteCode[*evmv10.GetBytecodeReturn](parser.ReturnKey, raw) + data, err := parse[*evmv10.GetBytecodeReturn, *evmv10.GetBytecodeReturn](raw, nil, false) + if err != nil { + return nil, err + } + // The return value is the same as the params + data[parser.ReturnKey] = data[parser.ParamsKey] + return data, nil } return nil, fmt.Errorf("unsupported height: %d", height) } @@ -109,17 +128,53 @@ func GetByteCode(height int64, raw []byte) (map[string]interface{}, error) { func GetByteCodeHash(height int64, raw []byte) (map[string]interface{}, error) { switch height { case 15: - return getByteCode[*abi.CborBytes](parser.ReturnKey, raw) + data, err := parse[*abi.CborBytes, *abi.CborBytes](raw, nil, false) + if err != nil { + return nil, err + } + // The return value is the same as the params + data[parser.ReturnKey] = data[parser.ParamsKey] + return data, nil case 14: - return getByteCode[*abi.CborBytes](parser.ReturnKey, raw) + data, err := parse[*abi.CborBytes, *abi.CborBytes](raw, nil, false) + if err != nil { + return nil, err + } + // The return value is the same as the params + data[parser.ReturnKey] = data[parser.ParamsKey] + return data, nil case 13: - return getByteCode[*abi.CborBytes](parser.ReturnKey, raw) + data, err := parse[*abi.CborBytes, *abi.CborBytes](raw, nil, false) + if err != nil { + return nil, err + } + // The return value is the same as the params + data[parser.ReturnKey] = data[parser.ParamsKey] + return data, nil case 12: - return getByteCode[*abi.CborBytes](parser.ReturnKey, raw) + data, err := parse[*abi.CborBytes, *abi.CborBytes](raw, nil, false) + if err != nil { + return nil, err + } + // The return value is the same as the params + data[parser.ReturnKey] = data[parser.ParamsKey] + return data, nil case 11: - return getByteCode[*abi.CborBytes](parser.ReturnKey, raw) + data, err := parse[*abi.CborBytes, *abi.CborBytes](raw, nil, false) + if err != nil { + return nil, err + } + // The return value is the same as the params + data[parser.ReturnKey] = data[parser.ParamsKey] + return data, nil case 10: - return getByteCode[*abi.CborBytes](parser.ReturnKey, raw) + data, err := parse[*abi.CborBytes, *abi.CborBytes](raw, nil, false) + if err != nil { + return nil, err + } + // The return value is the same as the params + data[parser.ReturnKey] = data[parser.ParamsKey] + return data, nil } return nil, fmt.Errorf("unsupported height: %d", height) } @@ -127,17 +182,17 @@ func GetByteCodeHash(height int64, raw []byte) (map[string]interface{}, error) { func EVMConstructor(height int64, raw []byte) (map[string]interface{}, error) { switch height { case 15: - return getByteCode[*evmv15.ConstructorParams](parser.ParamsKey, raw) + return parse[*evmv15.ConstructorParams, *evmv15.ConstructorParams](raw, nil, false) case 14: - return getByteCode[*evmv14.ConstructorParams](parser.ParamsKey, raw) + return parse[*evmv14.ConstructorParams, *evmv14.ConstructorParams](raw, nil, false) case 13: - return getByteCode[*evmv13.ConstructorParams](parser.ParamsKey, raw) + return parse[*evmv13.ConstructorParams, *evmv13.ConstructorParams](raw, nil, false) case 12: - return getByteCode[*evmv12.ConstructorParams](parser.ParamsKey, raw) + return parse[*evmv12.ConstructorParams, *evmv12.ConstructorParams](raw, nil, false) case 11: - return getByteCode[*evmv11.ConstructorParams](parser.ParamsKey, raw) + return parse[*evmv11.ConstructorParams, *evmv11.ConstructorParams](raw, nil, false) case 10: - return getByteCode[*evmv10.ConstructorParams](parser.ParamsKey, raw) + return parse[*evmv10.ConstructorParams, *evmv10.ConstructorParams](raw, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) } @@ -145,67 +200,17 @@ func EVMConstructor(height int64, raw []byte) (map[string]interface{}, error) { func GetStorageAt(height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { switch height { case 15: - return getStorageAt[*evmv15.GetStorageAtParams, *abi.CborBytes](rawParams, rawReturn) + return parse[*evmv15.GetStorageAtParams, *abi.CborBytes](rawParams, rawReturn, true) case 14: - return getStorageAt[*evmv14.GetStorageAtParams, *abi.CborBytes](rawParams, rawReturn) + return parse[*evmv14.GetStorageAtParams, *abi.CborBytes](rawParams, rawReturn, true) case 13: - return getStorageAt[*evmv13.GetStorageAtParams, *abi.CborBytes](rawParams, rawReturn) + return parse[*evmv13.GetStorageAtParams, *abi.CborBytes](rawParams, rawReturn, true) case 12: - return getStorageAt[*evmv12.GetStorageAtParams, *abi.CborBytes](rawParams, rawReturn) + return parse[*evmv12.GetStorageAtParams, *abi.CborBytes](rawParams, rawReturn, true) case 11: - return getStorageAt[*evmv11.GetStorageAtParams, *abi.CborBytes](rawParams, rawReturn) + return parse[*evmv11.GetStorageAtParams, *abi.CborBytes](rawParams, rawReturn, true) case 10: - return getStorageAt[*evmv10.GetStorageAtParams, *abi.CborBytes](rawParams, rawReturn) + return parse[*evmv10.GetStorageAtParams, *abi.CborBytes](rawParams, rawReturn, true) } return nil, fmt.Errorf("unsupported height: %d", height) } - -func invokeContractDelegate[T evmParams, R evmReturn](rawParams, rawReturn []byte) (map[string]interface{}, error) { - metadata := make(map[string]interface{}) - reader := bytes.NewReader(rawParams) - var params T - err := params.UnmarshalCBOR(reader) - if err != nil { - return metadata, err - } - metadata[parser.ParamsKey] = params - reader = bytes.NewReader(rawReturn) - var r R - err = r.UnmarshalCBOR(reader) - if err != nil { - return metadata, err - } - metadata[parser.ReturnKey] = r - return metadata, nil -} - -func getByteCode[R evmReturn](key string, raw []byte) (map[string]interface{}, error) { - metadata := make(map[string]interface{}) - reader := bytes.NewReader(raw) - var r R - err := r.UnmarshalCBOR(reader) - if err != nil { - return metadata, err - } - metadata[key] = r - return metadata, nil -} - -func getStorageAt[T evmParams, R evmReturn](rawParams, rawReturn []byte) (map[string]interface{}, error) { - metadata := make(map[string]interface{}) - reader := bytes.NewReader(rawParams) - var params T - err := params.UnmarshalCBOR(reader) - if err != nil { - return metadata, err - } - metadata[parser.ParamsKey] = params - reader = bytes.NewReader(rawReturn) - var r R - err = r.UnmarshalCBOR(reader) - if err != nil { - return metadata, err - } - metadata[parser.ReturnKey] = r - return metadata, nil -} diff --git a/actors/evm/generic.go b/actors/evm/generic.go new file mode 100644 index 00000000..8e72dd10 --- /dev/null +++ b/actors/evm/generic.go @@ -0,0 +1,80 @@ +package evm + +import ( + "bytes" + + "github.com/zondax/fil-parser/parser" +) + +func parse[T evmParams, R evmReturn](rawParams, rawReturn []byte, customReturn bool) (map[string]interface{}, error) { + metadata := make(map[string]interface{}) + reader := bytes.NewReader(rawParams) + var params T + err := params.UnmarshalCBOR(reader) + if err != nil { + return metadata, err + } + metadata[parser.ParamsKey] = params + if !customReturn { + return metadata, nil + } + + reader = bytes.NewReader(rawReturn) + var r R + err = r.UnmarshalCBOR(reader) + if err != nil { + return metadata, err + } + metadata[parser.ReturnKey] = r + return metadata, nil +} + +func invokeContractDelegate[T evmParams, R evmReturn](rawParams, rawReturn []byte) (map[string]interface{}, error) { + metadata := make(map[string]interface{}) + reader := bytes.NewReader(rawParams) + var params T + err := params.UnmarshalCBOR(reader) + if err != nil { + return metadata, err + } + metadata[parser.ParamsKey] = params + reader = bytes.NewReader(rawReturn) + var r R + err = r.UnmarshalCBOR(reader) + if err != nil { + return metadata, err + } + metadata[parser.ReturnKey] = r + return metadata, nil +} + +func getByteCode[R evmReturn](key string, raw []byte) (map[string]interface{}, error) { + metadata := make(map[string]interface{}) + reader := bytes.NewReader(raw) + var r R + err := r.UnmarshalCBOR(reader) + if err != nil { + return metadata, err + } + metadata[key] = r + return metadata, nil +} + +func getStorageAt[T evmParams, R evmReturn](rawParams, rawReturn []byte) (map[string]interface{}, error) { + metadata := make(map[string]interface{}) + reader := bytes.NewReader(rawParams) + var params T + err := params.UnmarshalCBOR(reader) + if err != nil { + return metadata, err + } + metadata[parser.ParamsKey] = params + reader = bytes.NewReader(rawReturn) + var r R + err = r.UnmarshalCBOR(reader) + if err != nil { + return metadata, err + } + metadata[parser.ReturnKey] = r + return metadata, nil +} diff --git a/actors/evm/types.go b/actors/evm/types.go new file mode 100644 index 00000000..b759cfad --- /dev/null +++ b/actors/evm/types.go @@ -0,0 +1,19 @@ +package evm + +import "io" + +type evmParams interface { + UnmarshalCBOR(io.Reader) error +} + +type evmReturn interface { + UnmarshalCBOR(io.Reader) error +} + +type createReturn interface { + UnmarshalCBOR(io.Reader) error +} + +type createReturnStruct[T any] struct { + CreateReturn T +} diff --git a/actors/init/generic.go b/actors/init/generic.go new file mode 100644 index 00000000..59074793 --- /dev/null +++ b/actors/init/generic.go @@ -0,0 +1,43 @@ +package init + +import ( + "bytes" + + "github.com/zondax/fil-parser/parser" + "github.com/zondax/fil-parser/types" +) + +func initConstructor[T constructorParams](raw []byte) (map[string]interface{}, error) { + metadata := make(map[string]interface{}) + reader := bytes.NewReader(raw) + var constructor T + err := constructor.UnmarshalCBOR(reader) + if err != nil { + return metadata, err + } + metadata[parser.ParamsKey] = constructor + return metadata, nil +} + +func parseExec[T constructorParams, R execReturn](msg *parser.LotusMessage, rawReturn []byte) (map[string]interface{}, *types.AddressInfo, error) { + metadata := make(map[string]interface{}) + reader := bytes.NewReader(msg.Params) + var params T + err := params.UnmarshalCBOR(reader) + if err != nil { + return metadata, nil, err + } + tmp := execParams(params) + metadata[parser.ParamsKey] = tmp + + reader = bytes.NewReader(rawReturn) + var r R + err = r.UnmarshalCBOR(reader) + if err != nil { + return metadata, nil, err + } + + createdActor := returnParams(msg, tmp.CodeCid, r) + metadata[parser.ReturnKey] = createdActor + return metadata, createdActor, nil +} diff --git a/actors/init/init.go b/actors/init/init.go index e924d1d6..42c7f8d1 100644 --- a/actors/init/init.go +++ b/actors/init/init.go @@ -1,10 +1,8 @@ package init import ( - "bytes" "encoding/base64" "fmt" - "io" "github.com/filecoin-project/go-address" builtinInitv10 "github.com/filecoin-project/go-state-types/builtin/v10/init" @@ -21,14 +19,6 @@ import ( "github.com/zondax/fil-parser/types" ) -type constructorParams interface { - UnmarshalCBOR(io.Reader) error -} - -type execReturn interface { - UnmarshalCBOR(io.Reader) error -} - func execParams(params constructorParams) parser.ExecParams { setParams := func(codeCid cid.Cid, constructorParams []byte) parser.ExecParams { return parser.ExecParams{ @@ -153,38 +143,3 @@ func ParseExec4(height int64, msg *parser.LotusMessage, raw []byte) (map[string] } return nil, nil, fmt.Errorf("unsupported height: %d", height) } - -func initConstructor[T constructorParams](raw []byte) (map[string]interface{}, error) { - metadata := make(map[string]interface{}) - reader := bytes.NewReader(raw) - var constructor T - err := constructor.UnmarshalCBOR(reader) - if err != nil { - return metadata, err - } - metadata[parser.ParamsKey] = constructor - return metadata, nil -} - -func parseExec[T constructorParams, R execReturn](msg *parser.LotusMessage, rawReturn []byte) (map[string]interface{}, *types.AddressInfo, error) { - metadata := make(map[string]interface{}) - reader := bytes.NewReader(msg.Params) - var params T - err := params.UnmarshalCBOR(reader) - if err != nil { - return metadata, nil, err - } - tmp := execParams(params) - metadata[parser.ParamsKey] = tmp - - reader = bytes.NewReader(rawReturn) - var r R - err = r.UnmarshalCBOR(reader) - if err != nil { - return metadata, nil, err - } - - createdActor := returnParams(msg, tmp.CodeCid, r) - metadata[parser.ReturnKey] = createdActor - return metadata, createdActor, nil -} diff --git a/actors/init/types.go b/actors/init/types.go new file mode 100644 index 00000000..e01a4794 --- /dev/null +++ b/actors/init/types.go @@ -0,0 +1,11 @@ +package init + +import "io" + +type constructorParams interface { + UnmarshalCBOR(io.Reader) error +} + +type execReturn interface { + UnmarshalCBOR(io.Reader) error +} diff --git a/actors/market/generic.go b/actors/market/generic.go new file mode 100644 index 00000000..9e2ce257 --- /dev/null +++ b/actors/market/generic.go @@ -0,0 +1,32 @@ +package market + +import ( + "bytes" + + "github.com/zondax/fil-parser/parser" +) + +func parseGeneric[T marketParam, R marketReturn](rawParams, rawReturn []byte, returnCustomParam bool) (map[string]interface{}, error) { + metadata := make(map[string]interface{}) + reader := bytes.NewReader(rawParams) + var params T + err := params.UnmarshalCBOR(reader) + if err != nil { + return metadata, err + } + + metadata[parser.ParamsKey] = params + if !returnCustomParam { + metadata[parser.ParamsKey] = getAddressAsString(params) + return metadata, nil + } + + reader = bytes.NewReader(rawReturn) + var publishReturn R + err = publishReturn.UnmarshalCBOR(reader) + if err != nil { + return metadata, err + } + metadata[parser.ReturnKey] = publishReturn + return metadata, nil +} diff --git a/actors/market/market.go b/actors/market/market.go index ed0e0fd1..fbbbbb06 100644 --- a/actors/market/market.go +++ b/actors/market/market.go @@ -1,9 +1,7 @@ package market import ( - "bytes" "fmt" - "io" "github.com/filecoin-project/go-address" v10Market "github.com/filecoin-project/go-state-types/builtin/v10/market" @@ -14,50 +12,8 @@ import ( v15Market "github.com/filecoin-project/go-state-types/builtin/v15/market" v8Market "github.com/filecoin-project/go-state-types/builtin/v8/market" v9Market "github.com/filecoin-project/go-state-types/builtin/v9/market" - - "github.com/zondax/fil-parser/parser" ) -type marketParam interface { - UnmarshalCBOR(io.Reader) error -} - -type marketReturn interface { - UnmarshalCBOR(io.Reader) error -} - -func getAddressAsString(addr any) string { - if address, ok := addr.(address.Address); ok { - return address.String() - } - return "" -} - -func parseGeneric[T marketParam, R marketReturn](rawParams, rawReturn []byte, returnCustomParam bool) (map[string]interface{}, error) { - metadata := make(map[string]interface{}) - reader := bytes.NewReader(rawParams) - var params T - err := params.UnmarshalCBOR(reader) - if err != nil { - return metadata, err - } - - metadata[parser.ParamsKey] = params - if !returnCustomParam { - metadata[parser.ParamsKey] = getAddressAsString(params) - return metadata, nil - } - - reader = bytes.NewReader(rawReturn) - var publishReturn R - err = publishReturn.UnmarshalCBOR(reader) - if err != nil { - return metadata, err - } - metadata[parser.ReturnKey] = publishReturn - return metadata, nil -} - func ParseAddBalance(height int64, rawParams []byte) (map[string]interface{}, error) { switch height { case 15: diff --git a/actors/market/types.go b/actors/market/types.go new file mode 100644 index 00000000..f56a08a2 --- /dev/null +++ b/actors/market/types.go @@ -0,0 +1,11 @@ +package market + +import "io" + +type marketParam interface { + UnmarshalCBOR(io.Reader) error +} + +type marketReturn interface { + UnmarshalCBOR(io.Reader) error +} diff --git a/actors/market/utils.go b/actors/market/utils.go new file mode 100644 index 00000000..dee771d1 --- /dev/null +++ b/actors/market/utils.go @@ -0,0 +1,10 @@ +package market + +import "github.com/filecoin-project/go-address" + +func getAddressAsString(addr any) string { + if address, ok := addr.(address.Address); ok { + return address.String() + } + return "" +} diff --git a/actors/miner/generic.go b/actors/miner/generic.go new file mode 100644 index 00000000..8d80ebc1 --- /dev/null +++ b/actors/miner/generic.go @@ -0,0 +1,29 @@ +package miner + +import ( + "bytes" + + "github.com/zondax/fil-parser/parser" +) + +func parseGeneric[T minerParam, R minerReturn](rawParams, rawReturn []byte, customReturn bool) (map[string]interface{}, error) { + metadata := make(map[string]interface{}) + reader := bytes.NewReader(rawParams) + var params T + err := params.UnmarshalCBOR(reader) + if err != nil { + return metadata, err + } + metadata[parser.ParamsKey] = params + if !customReturn { + return metadata, nil + } + reader = bytes.NewReader(rawReturn) + var r R + err = r.UnmarshalCBOR(reader) + if err != nil { + return metadata, err + } + metadata[parser.ReturnKey] = r + return metadata, nil +} diff --git a/actors/miner/miner.go b/actors/miner/miner.go index e2ae3307..5b77a39f 100644 --- a/actors/miner/miner.go +++ b/actors/miner/miner.go @@ -1,9 +1,7 @@ package miner import ( - "bytes" "fmt" - "io" miner10 "github.com/filecoin-project/go-state-types/builtin/v10/miner" miner11 "github.com/filecoin-project/go-state-types/builtin/v11/miner" @@ -13,39 +11,8 @@ import ( miner15 "github.com/filecoin-project/go-state-types/builtin/v15/miner" miner8 "github.com/filecoin-project/go-state-types/builtin/v8/miner" miner9 "github.com/filecoin-project/go-state-types/builtin/v9/miner" - "github.com/zondax/fil-parser/parser" ) -type minerParam interface { - UnmarshalCBOR(io.Reader) error -} - -type minerReturn interface { - UnmarshalCBOR(io.Reader) error -} - -func parseGeneric[T minerParam, R minerReturn](rawParams, rawReturn []byte, customReturn bool) (map[string]interface{}, error) { - metadata := make(map[string]interface{}) - reader := bytes.NewReader(rawParams) - var params T - err := params.UnmarshalCBOR(reader) - if err != nil { - return metadata, err - } - metadata[parser.ParamsKey] = params - if !customReturn { - return metadata, nil - } - reader = bytes.NewReader(rawReturn) - var r R - err = r.UnmarshalCBOR(reader) - if err != nil { - return metadata, err - } - metadata[parser.ReturnKey] = r - return metadata, nil -} - func TerminateSectors(height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { switch height { case 15: diff --git a/actors/miner/types.go b/actors/miner/types.go new file mode 100644 index 00000000..b3823985 --- /dev/null +++ b/actors/miner/types.go @@ -0,0 +1,11 @@ +package miner + +import "io" + +type minerParam interface { + UnmarshalCBOR(io.Reader) error +} + +type minerReturn interface { + UnmarshalCBOR(io.Reader) error +} diff --git a/actors/multisig/generic.go b/actors/multisig/generic.go new file mode 100644 index 00000000..c3a500b8 --- /dev/null +++ b/actors/multisig/generic.go @@ -0,0 +1,37 @@ +package multisig + +import ( + "encoding/json" + "fmt" + "io" +) + +func getValue[T multisigParams](height int64, raw map[string]interface{}) (interface{}, error) { + paramsRaw, ok := raw["Params"].(map[string]interface{}) + if !ok { + return nil, fmt.Errorf("Params not found or not a map[string]interface{}") + } + + var v T + err := mapToStruct(paramsRaw, &v) + if err != nil { + return nil, err + } + return v, nil +} + +func jsonUnmarshaller[T multisigParams](reader io.Reader, to any) error { + err := json.NewDecoder(reader).Decode(to) + if err != nil { + return err + } + return nil +} + +func cborUnmarshaller[T multisigParams](reader io.Reader, to any) error { + return to.(T).UnmarshalCBOR(reader) +} + +func noopUnmarshaller[T multisigParams](reader io.Reader, to any) error { + return nil +} diff --git a/actors/multisig/types.go b/actors/multisig/types.go index 9c9c5e70..0e82d487 100644 --- a/actors/multisig/types.go +++ b/actors/multisig/types.go @@ -1,20 +1,25 @@ package multisig import ( - "encoding/json" "io" + + filTypes "github.com/filecoin-project/lotus/chain/types" + "github.com/zondax/fil-parser/parser" ) -type WithCBOR struct { +type multisigParams interface { + UnmarshalCBOR(io.Reader) error } -func (w *WithCBOR) UnmarshalCBOR(reader io.Reader) error { - return nil +type multisigReturn interface { + UnmarshalCBOR(io.Reader) error } -func (w *WithCBOR) MarshalCBOR(writer io.Writer) error { - return nil -} +type parseFn func(*parser.LotusMessage, int64, filTypes.TipSetKey) (string, error) + +type metadataWithCbor map[string]interface{} + +type WithCBOR struct{} type ChangeOwnerAddressParams struct { WithCBOR @@ -40,14 +45,6 @@ type CancelValue struct { ProposalHash string `json:"ProposalHash"` } -func mapToStruct(m map[string]interface{}, v interface{}) error { - data, err := json.Marshal(m) - if err != nil { - return err - } - return json.Unmarshal(data, v) -} - type SendValue struct { WithCBOR Params interface{} `json:"Params"` @@ -79,3 +76,15 @@ type UniversalReceiverHookResults struct { SuccessCount int `json:"SuccessCount"` FailCodes interface{} `json:"FailCodes"` } + +func (m metadataWithCbor) UnmarshalCBOR(reader io.Reader) error { + return nil +} + +func (w *WithCBOR) UnmarshalCBOR(reader io.Reader) error { + return nil +} + +func (w *WithCBOR) MarshalCBOR(writer io.Writer) error { + return nil +} diff --git a/actors/multisig/utils.go b/actors/multisig/utils.go index eae95af4..3092d615 100644 --- a/actors/multisig/utils.go +++ b/actors/multisig/utils.go @@ -3,45 +3,8 @@ package multisig import ( "encoding/json" "errors" - "fmt" - "io" - - filTypes "github.com/filecoin-project/lotus/chain/types" - "github.com/zondax/fil-parser/parser" ) -type multisigParams interface { - UnmarshalCBOR(io.Reader) error -} - -type multisigReturn interface { - UnmarshalCBOR(io.Reader) error -} - -type parseFn func(*parser.LotusMessage, int64, filTypes.TipSetKey) (string, error) - -type metadataWithCbor map[string]interface{} - -func (m metadataWithCbor) UnmarshalCBOR(reader io.Reader) error { - return nil -} - -func jsonUnmarshaller[T multisigParams](reader io.Reader, to any) error { - err := json.NewDecoder(reader).Decode(to) - if err != nil { - return err - } - return nil -} - -func cborUnmarshaller[T multisigParams](reader io.Reader, to any) error { - return to.(T).UnmarshalCBOR(reader) -} - -func noopUnmarshaller[T multisigParams](reader io.Reader, to any) error { - return nil -} - func toBytes(raw any) ([]byte, error) { switch v := raw.(type) { case []byte: @@ -52,16 +15,10 @@ func toBytes(raw any) ([]byte, error) { return nil, errors.New("invalid type") } -func getValue[T multisigParams](height int64, raw map[string]interface{}) (interface{}, error) { - paramsRaw, ok := raw["Params"].(map[string]interface{}) - if !ok { - return nil, fmt.Errorf("Params not found or not a map[string]interface{}") - } - - var v T - err := mapToStruct(paramsRaw, &v) +func mapToStruct(m map[string]interface{}, v interface{}) error { + data, err := json.Marshal(m) if err != nil { - return nil, err + return err } - return v, nil + return json.Unmarshal(data, v) } diff --git a/actors/paymentChannel/generic.go b/actors/paymentChannel/generic.go new file mode 100644 index 00000000..114b0aa6 --- /dev/null +++ b/actors/paymentChannel/generic.go @@ -0,0 +1,19 @@ +package paymentchannel + +import ( + "bytes" + + "github.com/zondax/fil-parser/parser" +) + +func parse[T paymentChannelParams](raw []byte) (map[string]interface{}, error) { + metadata := make(map[string]interface{}) + reader := bytes.NewReader(raw) + var constructor T + err := constructor.UnmarshalCBOR(reader) + if err != nil { + return metadata, err + } + metadata[parser.ParamsKey] = constructor + return metadata, nil +} diff --git a/actors/paymentChannel/paymentChannel.go b/actors/paymentChannel/paymentChannel.go index 4148cd4f..73e13e81 100644 --- a/actors/paymentChannel/paymentChannel.go +++ b/actors/paymentChannel/paymentChannel.go @@ -1,7 +1,6 @@ package paymentchannel import ( - "bytes" "io" paychv10 "github.com/filecoin-project/go-state-types/builtin/v10/paych" @@ -12,7 +11,6 @@ import ( paychv15 "github.com/filecoin-project/go-state-types/builtin/v15/paych" paychv8 "github.com/filecoin-project/go-state-types/builtin/v8/paych" paychv9 "github.com/filecoin-project/go-state-types/builtin/v9/paych" - "github.com/zondax/fil-parser/parser" ) type paymentChannelParams interface { @@ -62,15 +60,3 @@ func UpdateChannelState(height int64, raw []byte) (map[string]interface{}, error } return nil, nil } - -func parse[T paymentChannelParams](raw []byte) (map[string]interface{}, error) { - metadata := make(map[string]interface{}) - reader := bytes.NewReader(raw) - var constructor T - err := constructor.UnmarshalCBOR(reader) - if err != nil { - return metadata, err - } - metadata[parser.ParamsKey] = constructor - return metadata, nil -} diff --git a/actors/power/generic.go b/actors/power/generic.go new file mode 100644 index 00000000..bdaa14ad --- /dev/null +++ b/actors/power/generic.go @@ -0,0 +1,33 @@ +package power + +import ( + "bytes" + + "github.com/zondax/fil-parser/parser" + "github.com/zondax/fil-parser/types" +) + +func parse[T powerParams, R powerReturn](msg *parser.LotusMessage, raw, rawReturn []byte, customReturn bool) (map[string]interface{}, *types.AddressInfo, error) { + metadata := make(map[string]interface{}) + reader := bytes.NewReader(raw) + var constructor T + err := constructor.UnmarshalCBOR(reader) + if err != nil { + return metadata, nil, err + } + + metadata[parser.ParamsKey] = constructor + if !customReturn { + return metadata, nil, nil + } + + reader = bytes.NewReader(rawReturn) + var r R + err = r.UnmarshalCBOR(reader) + if err != nil { + return metadata, nil, err + } + createdActor := getAddressInfo(r, msg) + metadata[parser.ReturnKey] = createdActor + return metadata, createdActor, nil +} diff --git a/actors/power/power.go b/actors/power/power.go index d84c24b7..e1ddbceb 100644 --- a/actors/power/power.go +++ b/actors/power/power.go @@ -1,88 +1,13 @@ package power import ( - "bytes" - "io" - - "github.com/filecoin-project/go-address" "github.com/filecoin-project/go-state-types/abi" - powerv10 "github.com/filecoin-project/go-state-types/builtin/v10/power" - powerv11 "github.com/filecoin-project/go-state-types/builtin/v11/power" - powerv12 "github.com/filecoin-project/go-state-types/builtin/v12/power" - powerv13 "github.com/filecoin-project/go-state-types/builtin/v13/power" - powerv14 "github.com/filecoin-project/go-state-types/builtin/v14/power" - powerv15 "github.com/filecoin-project/go-state-types/builtin/v15/power" powerv8 "github.com/filecoin-project/go-state-types/builtin/v8/power" powerv9 "github.com/filecoin-project/go-state-types/builtin/v9/power" "github.com/filecoin-project/go-state-types/proof" - "github.com/ipfs/go-cid" "github.com/zondax/fil-parser/parser" - "github.com/zondax/fil-parser/types" ) -type powerParams interface { - UnmarshalCBOR(io.Reader) error -} - -type powerReturn interface { - UnmarshalCBOR(io.Reader) error -} - -func getAddressInfo(r powerReturn, msg *parser.LotusMessage) *types.AddressInfo { - createAddressInfo := func(idAddress, robustAddress address.Address, cid cid.Cid) *types.AddressInfo { - return &types.AddressInfo{ - Short: idAddress.String(), - Robust: robustAddress.String(), - ActorType: "miner", - CreationTxCid: cid.String(), - } - } - switch r := r.(type) { - case *powerv8.CreateMinerReturn: - return createAddressInfo(r.IDAddress, r.RobustAddress, msg.Cid) - case *powerv9.CreateMinerReturn: - return createAddressInfo(r.IDAddress, r.RobustAddress, msg.Cid) - case *powerv10.CreateMinerReturn: - return createAddressInfo(r.IDAddress, r.RobustAddress, msg.Cid) - case *powerv11.CreateMinerReturn: - return createAddressInfo(r.IDAddress, r.RobustAddress, msg.Cid) - case *powerv12.CreateMinerReturn: - return createAddressInfo(r.IDAddress, r.RobustAddress, msg.Cid) - case *powerv13.CreateMinerReturn: - return createAddressInfo(r.IDAddress, r.RobustAddress, msg.Cid) - case *powerv14.CreateMinerReturn: - return createAddressInfo(r.IDAddress, r.RobustAddress, msg.Cid) - case *powerv15.CreateMinerReturn: - return createAddressInfo(r.IDAddress, r.RobustAddress, msg.Cid) - } - return nil -} - -func parse[T powerParams, R powerReturn](msg *parser.LotusMessage, raw, rawReturn []byte, customReturn bool) (map[string]interface{}, *types.AddressInfo, error) { - metadata := make(map[string]interface{}) - reader := bytes.NewReader(raw) - var constructor T - err := constructor.UnmarshalCBOR(reader) - if err != nil { - return metadata, nil, err - } - - metadata[parser.ParamsKey] = constructor - if !customReturn { - return metadata, nil, nil - } - - reader = bytes.NewReader(rawReturn) - var r R - err = r.UnmarshalCBOR(reader) - if err != nil { - return metadata, nil, err - } - createdActor := getAddressInfo(r, msg) - metadata[parser.ReturnKey] = createdActor - return metadata, createdActor, nil -} - func CurrentTotalPower(msg *parser.LotusMessage, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch height { case 8: diff --git a/actors/power/types.go b/actors/power/types.go new file mode 100644 index 00000000..a0fc7609 --- /dev/null +++ b/actors/power/types.go @@ -0,0 +1,11 @@ +package power + +import "io" + +type powerParams interface { + UnmarshalCBOR(io.Reader) error +} + +type powerReturn interface { + UnmarshalCBOR(io.Reader) error +} diff --git a/actors/power/utils.go b/actors/power/utils.go new file mode 100644 index 00000000..24867cf9 --- /dev/null +++ b/actors/power/utils.go @@ -0,0 +1,46 @@ +package power + +import ( + "github.com/filecoin-project/go-address" + powerv10 "github.com/filecoin-project/go-state-types/builtin/v10/power" + powerv11 "github.com/filecoin-project/go-state-types/builtin/v11/power" + powerv12 "github.com/filecoin-project/go-state-types/builtin/v12/power" + powerv13 "github.com/filecoin-project/go-state-types/builtin/v13/power" + powerv14 "github.com/filecoin-project/go-state-types/builtin/v14/power" + powerv15 "github.com/filecoin-project/go-state-types/builtin/v15/power" + powerv8 "github.com/filecoin-project/go-state-types/builtin/v8/power" + powerv9 "github.com/filecoin-project/go-state-types/builtin/v9/power" + "github.com/ipfs/go-cid" + "github.com/zondax/fil-parser/parser" + "github.com/zondax/fil-parser/types" +) + +func getAddressInfo(r powerReturn, msg *parser.LotusMessage) *types.AddressInfo { + createAddressInfo := func(idAddress, robustAddress address.Address, cid cid.Cid) *types.AddressInfo { + return &types.AddressInfo{ + Short: idAddress.String(), + Robust: robustAddress.String(), + ActorType: "miner", + CreationTxCid: cid.String(), + } + } + switch r := r.(type) { + case *powerv8.CreateMinerReturn: + return createAddressInfo(r.IDAddress, r.RobustAddress, msg.Cid) + case *powerv9.CreateMinerReturn: + return createAddressInfo(r.IDAddress, r.RobustAddress, msg.Cid) + case *powerv10.CreateMinerReturn: + return createAddressInfo(r.IDAddress, r.RobustAddress, msg.Cid) + case *powerv11.CreateMinerReturn: + return createAddressInfo(r.IDAddress, r.RobustAddress, msg.Cid) + case *powerv12.CreateMinerReturn: + return createAddressInfo(r.IDAddress, r.RobustAddress, msg.Cid) + case *powerv13.CreateMinerReturn: + return createAddressInfo(r.IDAddress, r.RobustAddress, msg.Cid) + case *powerv14.CreateMinerReturn: + return createAddressInfo(r.IDAddress, r.RobustAddress, msg.Cid) + case *powerv15.CreateMinerReturn: + return createAddressInfo(r.IDAddress, r.RobustAddress, msg.Cid) + } + return nil +} diff --git a/actors/reward/generic.go b/actors/reward/generic.go new file mode 100644 index 00000000..3d482b90 --- /dev/null +++ b/actors/reward/generic.go @@ -0,0 +1,19 @@ +package reward + +import ( + "bytes" + + "github.com/zondax/fil-parser/parser" +) + +func parse[T rewardParams](raw []byte) (map[string]interface{}, error) { + metadata := make(map[string]interface{}) + reader := bytes.NewReader(raw) + var params T + err := params.UnmarshalCBOR(reader) + if err != nil { + return metadata, err + } + metadata[parser.ParamsKey] = params + return metadata, nil +} diff --git a/actors/reward/reward.go b/actors/reward/reward.go index 8fa1eb86..281d84a7 100644 --- a/actors/reward/reward.go +++ b/actors/reward/reward.go @@ -1,31 +1,11 @@ package reward import ( - "bytes" - "io" - "github.com/filecoin-project/go-state-types/abi" rewardv11 "github.com/filecoin-project/go-state-types/builtin/v11/reward" rewardv8 "github.com/filecoin-project/go-state-types/builtin/v8/reward" - "github.com/zondax/fil-parser/parser" ) -type rewardParams interface { - UnmarshalCBOR(io.Reader) error -} - -func parse[T rewardParams](raw []byte) (map[string]interface{}, error) { - metadata := make(map[string]interface{}) - reader := bytes.NewReader(raw) - var params T - err := params.UnmarshalCBOR(reader) - if err != nil { - return metadata, err - } - metadata[parser.ParamsKey] = params - return metadata, nil -} - func RewardConstructor(height int64, raw []byte) (map[string]interface{}, error) { return parse[*abi.StoragePower](raw) } diff --git a/actors/reward/types.go b/actors/reward/types.go new file mode 100644 index 00000000..0448ba5f --- /dev/null +++ b/actors/reward/types.go @@ -0,0 +1,7 @@ +package reward + +import "io" + +type rewardParams interface { + UnmarshalCBOR(io.Reader) error +} diff --git a/actors/verifiedRegistry/generic.go b/actors/verifiedRegistry/generic.go new file mode 100644 index 00000000..349236e1 --- /dev/null +++ b/actors/verifiedRegistry/generic.go @@ -0,0 +1,29 @@ +package verifiedregistry + +import ( + "bytes" + + "github.com/zondax/fil-parser/parser" +) + +func parse[T verifiedRegistryParams, R verifiedRegistryReturn](raw, rawReturn []byte, customReturn bool) (map[string]interface{}, error) { + metadata := make(map[string]interface{}) + reader := bytes.NewReader(raw) + var params T + err := params.UnmarshalCBOR(reader) + if err != nil { + return metadata, err + } + metadata[parser.ParamsKey] = params + if customReturn { + return metadata, nil + } + reader = bytes.NewReader(rawReturn) + var r R + err = r.UnmarshalCBOR(reader) + if err != nil { + return metadata, err + } + metadata[parser.ReturnKey] = r + return metadata, nil +} diff --git a/actors/verifiedRegistry/types.go b/actors/verifiedRegistry/types.go new file mode 100644 index 00000000..f15f9e3c --- /dev/null +++ b/actors/verifiedRegistry/types.go @@ -0,0 +1,11 @@ +package verifiedregistry + +import "io" + +type verifiedRegistryParams interface { + UnmarshalCBOR(io.Reader) error +} + +type verifiedRegistryReturn interface { + UnmarshalCBOR(io.Reader) error +} diff --git a/actors/verifiedRegistry/verifiedRegistry.go b/actors/verifiedRegistry/verifiedRegistry.go index 773841b9..37ff596f 100644 --- a/actors/verifiedRegistry/verifiedRegistry.go +++ b/actors/verifiedRegistry/verifiedRegistry.go @@ -1,45 +1,11 @@ package verifiedregistry import ( - "bytes" - "io" - "github.com/filecoin-project/go-address" verifregv11 "github.com/filecoin-project/go-state-types/builtin/v11/verifreg" verifregv8 "github.com/filecoin-project/go-state-types/builtin/v8/verifreg" - "github.com/zondax/fil-parser/parser" ) -type verifiedRegistryParams interface { - UnmarshalCBOR(io.Reader) error -} - -type verifiedRegistryReturn interface { - UnmarshalCBOR(io.Reader) error -} - -func parse[T verifiedRegistryParams, R verifiedRegistryReturn](raw, rawReturn []byte, customReturn bool) (map[string]interface{}, error) { - metadata := make(map[string]interface{}) - reader := bytes.NewReader(raw) - var params T - err := params.UnmarshalCBOR(reader) - if err != nil { - return metadata, err - } - metadata[parser.ParamsKey] = params - if customReturn { - return metadata, nil - } - reader = bytes.NewReader(rawReturn) - var r R - err = r.UnmarshalCBOR(reader) - if err != nil { - return metadata, err - } - metadata[parser.ReturnKey] = r - return metadata, nil -} - func AddVerifier(height int64, raw []byte) (map[string]interface{}, error) { switch height { case 8: From a278db25026cf7685d1aa39af7e55b47f59a8674 Mon Sep 17 00:00:00 2001 From: Eric Mokaya Date: Tue, 21 Jan 2025 22:19:20 +0300 Subject: [PATCH 05/16] feat: add correct height switch logic --- actors/account/account.go | 16 +- actors/cron/cron.go | 19 +- actors/datacap/allowance.go | 130 +++--- actors/datacap/burn.go | 123 +++--- actors/datacap/datacap.go | 38 +- actors/datacap/generic.go | 31 ++ actors/datacap/granularity.go | 75 ++-- actors/datacap/mint.go | 62 +-- actors/datacap/transfer.go | 62 +-- actors/datacap/types.go | 15 + actors/eam/create.go | 49 +-- actors/evm/evm.go | 83 ++-- actors/init/init.go | 55 +-- actors/market/market.go | 374 ++++++++-------- actors/miner/address.go | 152 ++++++- actors/miner/balance.go | 62 ++- actors/miner/miner.go | 239 ++++++++--- actors/miner/sector.go | 224 ++++++++-- actors/multisig/generic.go | 48 +++ actors/multisig/multisig.go | 192 ++++++--- actors/multisig/utils.go | 161 +++++++ actors/multisig/values.go | 446 +++++++++++++++----- actors/multisig/verifier.go | 30 +- actors/paymentChannel/paymentChannel.go | 37 +- actors/power/power.go | 256 ++++++++++- actors/reward/reward.go | 43 +- actors/verifiedRegistry.go | 1 + actors/verifiedRegistry/verifiedRegistry.go | 242 +++++++++-- tools/version_mapping.go | 47 +++ 29 files changed, 2347 insertions(+), 965 deletions(-) create mode 100644 actors/datacap/generic.go create mode 100644 actors/datacap/types.go create mode 100644 tools/version_mapping.go diff --git a/actors/account/account.go b/actors/account/account.go index 69814be2..8da8dfa7 100644 --- a/actors/account/account.go +++ b/actors/account/account.go @@ -12,6 +12,7 @@ import ( accountv14 "github.com/filecoin-project/go-state-types/builtin/v14/account" accountv15 "github.com/filecoin-project/go-state-types/builtin/v15/account" "github.com/zondax/fil-parser/parser" + "github.com/zondax/fil-parser/tools" ) func PubkeyAddress(raw, rawReturn []byte) (map[string]interface{}, error) { @@ -28,19 +29,18 @@ func PubkeyAddress(raw, rawReturn []byte) (map[string]interface{}, error) { } func AuthenticateMessage(height int64, raw, rawReturn []byte) (map[string]interface{}, error) { - switch height { - case 8: + switch { + case tools.V8.IsSupported(height): return nil, fmt.Errorf("not supported") - case 9: + case tools.V9.IsSupported(height): return authenticateMessageGeneric[*accountv9.AuthenticateMessageParams, *accountv9.AuthenticateMessageParams](raw, rawReturn, &accountv9.AuthenticateMessageParams{}) - case 10: + case tools.V10.IsSupported(height): return authenticateMessageGeneric[*accountv10.AuthenticateMessageParams, *accountv10.AuthenticateMessageParams](raw, rawReturn, &accountv10.AuthenticateMessageParams{}) - case 11: + case tools.V11.IsSupported(height): return authenticateMessageGeneric[*accountv11.AuthenticateMessageParams, *accountv11.AuthenticateMessageParams](raw, rawReturn, &accountv11.AuthenticateMessageParams{}) - case 14: + case tools.V14.IsSupported(height): return authenticateMessageGeneric[*accountv14.AuthenticateMessageParams, *accountv14.AuthenticateMessageParams](raw, rawReturn, &accountv14.AuthenticateMessageParams{}) - case 15: + default: return authenticateMessageGeneric[*accountv15.AuthenticateMessageParams, *accountv15.AuthenticateMessageParams](raw, rawReturn, &accountv15.AuthenticateMessageParams{}) } - return nil, nil } diff --git a/actors/cron/cron.go b/actors/cron/cron.go index 1f60e692..8e439d6b 100644 --- a/actors/cron/cron.go +++ b/actors/cron/cron.go @@ -8,24 +8,25 @@ import ( cronv6 "github.com/filecoin-project/specs-actors/v6/actors/builtin/cron" cronv7 "github.com/filecoin-project/specs-actors/v7/actors/builtin/cron" cronv8 "github.com/filecoin-project/specs-actors/v8/actors/builtin/cron" + "github.com/zondax/fil-parser/tools" ) // TODO: update to correct height ranges -func CronConstructor(height uint64, raw []byte) (map[string]interface{}, error) { - switch height { - case 8: +func CronConstructor(height int64, raw []byte) (map[string]interface{}, error) { + switch { + case tools.V8.IsSupported(height): return cronConstructorGeneric[*cronv8.ConstructorParams](raw, &cronv8.ConstructorParams{}) - case 7: + case tools.V7.IsSupported(height): return cronConstructorGeneric[*cronv7.ConstructorParams](raw, &cronv7.ConstructorParams{}) - case 6: + case tools.V6.IsSupported(height): return cronConstructorGeneric[*cronv6.ConstructorParams](raw, &cronv6.ConstructorParams{}) - case 5: + case tools.V5.IsSupported(height): return cronConstructorGeneric[*cronv5.ConstructorParams](raw, &cronv5.ConstructorParams{}) - case 4: + case tools.V4.IsSupported(height): return cronConstructorGeneric[*cronv4.ConstructorParams](raw, &cronv4.ConstructorParams{}) - case 3: + case tools.V3.IsSupported(height): return cronConstructorGeneric[*cronv3.ConstructorParams](raw, &cronv3.ConstructorParams{}) - case 2: + case tools.V2.IsSupported(height): return cronConstructorGeneric[*cronv2.ConstructorParams](raw, &cronv2.ConstructorParams{}) } return nil, nil diff --git a/actors/datacap/allowance.go b/actors/datacap/allowance.go index a1e43410..0046ca63 100644 --- a/actors/datacap/allowance.go +++ b/actors/datacap/allowance.go @@ -1,7 +1,6 @@ package datacap import ( - "bytes" "fmt" "github.com/filecoin-project/go-state-types/abi" @@ -10,100 +9,77 @@ import ( datacapv14 "github.com/filecoin-project/go-state-types/builtin/v14/datacap" datacapv15 "github.com/filecoin-project/go-state-types/builtin/v15/datacap" datacapv9 "github.com/filecoin-project/go-state-types/builtin/v9/datacap" - "github.com/zondax/fil-parser/parser" + "github.com/zondax/fil-parser/tools" ) -type allowanceParamsInterface interface { - unmarshalCBOR -} - -func allowanceGeneric[T allowanceParamsInterface](raw []byte, rawReturn []byte, params T) (map[string]interface{}, error) { - metadata := make(map[string]interface{}) - reader := bytes.NewReader(raw) - err := params.UnmarshalCBOR(reader) - if err != nil { - return metadata, err - } - metadata[parser.ParamsKey] = params - - reader = bytes.NewReader(rawReturn) - var r abi.TokenAmount - err = r.UnmarshalCBOR(reader) - if err != nil { - return metadata, err - } - metadata[parser.ReturnKey] = r - return metadata, nil -} - -func IncreaseAllowance(height uint64, raw, rawReturn []byte) (map[string]interface{}, error) { - switch height { - case 8: +func IncreaseAllowance(height int64, raw, rawReturn []byte) (map[string]interface{}, error) { + switch { + case tools.V8.IsSupported(height): return nil, fmt.Errorf("not supported") - case 9: - return allowanceGeneric[*datacapv9.IncreaseAllowanceParams](raw, rawReturn, &datacapv9.IncreaseAllowanceParams{}) - case 10: - return allowanceGeneric[*datacapv10.IncreaseAllowanceParams](raw, rawReturn, &datacapv10.IncreaseAllowanceParams{}) - case 11: - return allowanceGeneric[*datacapv11.IncreaseAllowanceParams](raw, rawReturn, &datacapv11.IncreaseAllowanceParams{}) - case 14: - return allowanceGeneric[*datacapv14.IncreaseAllowanceParams](raw, rawReturn, &datacapv14.IncreaseAllowanceParams{}) - case 15: - return allowanceGeneric[*datacapv15.IncreaseAllowanceParams](raw, rawReturn, &datacapv15.IncreaseAllowanceParams{}) + case tools.V9.IsSupported(height): + return parse[*datacapv9.IncreaseAllowanceParams, *abi.TokenAmount](raw, rawReturn, true) + case tools.V10.IsSupported(height): + return parse[*datacapv10.IncreaseAllowanceParams, *abi.TokenAmount](raw, rawReturn, true) + case tools.V11.IsSupported(height): + return parse[*datacapv11.IncreaseAllowanceParams, *abi.TokenAmount](raw, rawReturn, true) + case tools.V14.IsSupported(height): + return parse[*datacapv14.IncreaseAllowanceParams, *abi.TokenAmount](raw, rawReturn, true) + case tools.V15.IsSupported(height): + return parse[*datacapv15.IncreaseAllowanceParams, *abi.TokenAmount](raw, rawReturn, true) } return nil, fmt.Errorf("not supported") } -func DecreaseAllowance(height uint64, raw, rawReturn []byte) (map[string]interface{}, error) { - switch height { - case 8: +func DecreaseAllowance(height int64, raw, rawReturn []byte) (map[string]interface{}, error) { + switch { + case tools.V8.IsSupported(height): return nil, fmt.Errorf("not supported") - case 9: - return allowanceGeneric[*datacapv9.DecreaseAllowanceParams](raw, rawReturn, &datacapv9.DecreaseAllowanceParams{}) - case 10: - return allowanceGeneric[*datacapv10.DecreaseAllowanceParams](raw, rawReturn, &datacapv10.DecreaseAllowanceParams{}) - case 11: - return allowanceGeneric[*datacapv11.DecreaseAllowanceParams](raw, rawReturn, &datacapv11.DecreaseAllowanceParams{}) - case 14: - return allowanceGeneric[*datacapv14.DecreaseAllowanceParams](raw, rawReturn, &datacapv14.DecreaseAllowanceParams{}) - case 15: - return allowanceGeneric[*datacapv15.DecreaseAllowanceParams](raw, rawReturn, &datacapv15.DecreaseAllowanceParams{}) + case tools.V9.IsSupported(height): + return parse[*datacapv9.DecreaseAllowanceParams, *abi.TokenAmount](raw, rawReturn, true) + case tools.V10.IsSupported(height): + return parse[*datacapv10.DecreaseAllowanceParams, *abi.TokenAmount](raw, rawReturn, true) + case tools.V11.IsSupported(height): + return parse[*datacapv11.DecreaseAllowanceParams, *abi.TokenAmount](raw, rawReturn, true) + case tools.V14.IsSupported(height): + return parse[*datacapv14.DecreaseAllowanceParams, *abi.TokenAmount](raw, rawReturn, true) + case tools.V15.IsSupported(height): + return parse[*datacapv15.DecreaseAllowanceParams, *abi.TokenAmount](raw, rawReturn, true) } return nil, fmt.Errorf("not supported") } -func RevokeAllowance(height uint64, raw, rawReturn []byte) (map[string]interface{}, error) { - switch height { - case 8: +func RevokeAllowance(height int64, raw, rawReturn []byte) (map[string]interface{}, error) { + switch { + case tools.V8.IsSupported(height): return nil, fmt.Errorf("not supported") - case 9: - return allowanceGeneric[*datacapv9.RevokeAllowanceParams](raw, rawReturn, &datacapv9.RevokeAllowanceParams{}) - case 10: - return allowanceGeneric[*datacapv10.RevokeAllowanceParams](raw, rawReturn, &datacapv10.RevokeAllowanceParams{}) - case 11: - return allowanceGeneric[*datacapv11.RevokeAllowanceParams](raw, rawReturn, &datacapv11.RevokeAllowanceParams{}) - case 14: - return allowanceGeneric[*datacapv14.RevokeAllowanceParams](raw, rawReturn, &datacapv14.RevokeAllowanceParams{}) - case 15: - return allowanceGeneric[*datacapv15.RevokeAllowanceParams](raw, rawReturn, &datacapv15.RevokeAllowanceParams{}) + case tools.V9.IsSupported(height): + return parse[*datacapv9.RevokeAllowanceParams, *abi.TokenAmount](raw, rawReturn, true) + case tools.V10.IsSupported(height): + return parse[*datacapv10.RevokeAllowanceParams, *abi.TokenAmount](raw, rawReturn, true) + case tools.V11.IsSupported(height): + return parse[*datacapv11.RevokeAllowanceParams, *abi.TokenAmount](raw, rawReturn, true) + case tools.V14.IsSupported(height): + return parse[*datacapv14.RevokeAllowanceParams, *abi.TokenAmount](raw, rawReturn, true) + case tools.V15.IsSupported(height): + return parse[*datacapv15.RevokeAllowanceParams, *abi.TokenAmount](raw, rawReturn, true) } return nil, fmt.Errorf("not supported") } -func GetAllowance(height uint64, raw, rawReturn []byte) (map[string]interface{}, error) { - switch height { - case 8: +func GetAllowance(height int64, raw, rawReturn []byte) (map[string]interface{}, error) { + switch { + case tools.V8.IsSupported(height): return nil, fmt.Errorf("not supported") - case 9: - return allowanceGeneric[*datacapv9.GetAllowanceParams](raw, rawReturn, &datacapv9.GetAllowanceParams{}) - case 10: - return allowanceGeneric[*datacapv10.GetAllowanceParams](raw, rawReturn, &datacapv10.GetAllowanceParams{}) - case 11: - return allowanceGeneric[*datacapv11.GetAllowanceParams](raw, rawReturn, &datacapv11.GetAllowanceParams{}) - case 14: - return allowanceGeneric[*datacapv14.GetAllowanceParams](raw, rawReturn, &datacapv14.GetAllowanceParams{}) - case 15: - return allowanceGeneric[*datacapv15.GetAllowanceParams](raw, rawReturn, &datacapv15.GetAllowanceParams{}) + case tools.V9.IsSupported(height): + return parse[*datacapv9.GetAllowanceParams, *abi.TokenAmount](raw, rawReturn, true) + case tools.V10.IsSupported(height): + return parse[*datacapv10.GetAllowanceParams, *abi.TokenAmount](raw, rawReturn, true) + case tools.V11.IsSupported(height): + return parse[*datacapv11.GetAllowanceParams, *abi.TokenAmount](raw, rawReturn, true) + case tools.V14.IsSupported(height): + return parse[*datacapv14.GetAllowanceParams, *abi.TokenAmount](raw, rawReturn, true) + case tools.V15.IsSupported(height): + return parse[*datacapv15.GetAllowanceParams, *abi.TokenAmount](raw, rawReturn, true) } return nil, fmt.Errorf("not supported") } diff --git a/actors/datacap/burn.go b/actors/datacap/burn.go index 511ab082..ebde2c3e 100644 --- a/actors/datacap/burn.go +++ b/actors/datacap/burn.go @@ -1,9 +1,7 @@ package datacap import ( - "bytes" "fmt" - "io" datacapv10 "github.com/filecoin-project/go-state-types/builtin/v10/datacap" datacapv11 "github.com/filecoin-project/go-state-types/builtin/v11/datacap" @@ -11,88 +9,73 @@ import ( datacapv13 "github.com/filecoin-project/go-state-types/builtin/v13/datacap" datacapv14 "github.com/filecoin-project/go-state-types/builtin/v14/datacap" datacapv15 "github.com/filecoin-project/go-state-types/builtin/v15/datacap" + datacapv8 "github.com/filecoin-project/go-state-types/builtin/v8/datacap" datacapv9 "github.com/filecoin-project/go-state-types/builtin/v9/datacap" - "github.com/zondax/fil-parser/parser" + "github.com/zondax/fil-parser/tools" ) -type burnParams interface { - UnmarshalCBOR(r io.Reader) error -} - -type burnReturn interface { - UnmarshalCBOR(r io.Reader) error -} - -func burnGeneric[P unmarshalCBOR, R unmarshalCBOR](raw []byte, rawReturn []byte, params P, r R) (map[string]interface{}, error) { - metadata := make(map[string]interface{}) - reader := bytes.NewReader(raw) - err := params.UnmarshalCBOR(reader) - if err != nil { - return metadata, err - } - metadata[parser.ParamsKey] = params - - reader = bytes.NewReader(rawReturn) - err = r.UnmarshalCBOR(reader) - if err != nil { - return metadata, err - } - metadata[parser.ReturnKey] = r - return metadata, nil -} - func BurnExported(height uint64, raw, rawReturn []byte) (map[string]interface{}, error) { - switch height { - case 9: - return burnGeneric[*datacapv9.BurnParams, *datacapv9.BurnReturn](raw, rawReturn, &datacapv9.BurnParams{}, &datacapv9.BurnReturn{}) - case 10: - return burnGeneric[*datacapv10.BurnParams, *datacapv10.BurnReturn](raw, rawReturn, &datacapv10.BurnParams{}, &datacapv10.BurnReturn{}) - case 11: - return burnGeneric[*datacapv11.BurnParams, *datacapv11.BurnReturn](raw, rawReturn, &datacapv11.BurnParams{}, &datacapv11.BurnReturn{}) - case 14: - return burnGeneric[*datacapv14.BurnParams, *datacapv14.BurnReturn](raw, rawReturn, &datacapv14.BurnParams{}, &datacapv14.BurnReturn{}) - case 15: - return burnGeneric[*datacapv15.BurnParams, *datacapv15.BurnReturn](raw, rawReturn, &datacapv15.BurnParams{}, &datacapv15.BurnReturn{}) + switch { + case tools.V8.IsSupported(int64(height)): + return parse[*datacapv8.BurnParams, *datacapv8.BurnReturn](raw, rawReturn, true) + case tools.V9.IsSupported(int64(height)): + return parse[*datacapv9.BurnParams, *datacapv9.BurnReturn](raw, rawReturn, true) + case tools.V10.IsSupported(int64(height)): + return parse[*datacapv10.BurnParams, *datacapv10.BurnReturn](raw, rawReturn, true) + case tools.V11.IsSupported(int64(height)): + return parse[*datacapv11.BurnParams, *datacapv11.BurnReturn](raw, rawReturn, true) + case tools.V12.IsSupported(int64(height)): + return parse[*datacapv12.BurnParams, *datacapv12.BurnReturn](raw, rawReturn, true) + case tools.V13.IsSupported(int64(height)): + return parse[*datacapv13.BurnParams, *datacapv13.BurnReturn](raw, rawReturn, true) + case tools.V14.IsSupported(int64(height)): + return parse[*datacapv14.BurnParams, *datacapv14.BurnReturn](raw, rawReturn, true) + case tools.V15.IsSupported(int64(height)): + return parse[*datacapv15.BurnParams, *datacapv15.BurnReturn](raw, rawReturn, true) } return nil, fmt.Errorf("not supported") } func BurnFromExported(height uint64, raw, rawReturn []byte) (map[string]interface{}, error) { - switch height { - case 9: - return burnGeneric[*datacapv9.BurnFromParams, *datacapv9.BurnFromReturn](raw, rawReturn, &datacapv9.BurnFromParams{}, &datacapv9.BurnFromReturn{}) - case 10: - return burnGeneric[*datacapv10.BurnFromParams, *datacapv10.BurnFromReturn](raw, rawReturn, &datacapv10.BurnFromParams{}, &datacapv10.BurnFromReturn{}) - case 11: - return burnGeneric[*datacapv11.BurnFromParams, *datacapv11.BurnFromReturn](raw, rawReturn, &datacapv11.BurnFromParams{}, &datacapv11.BurnFromReturn{}) - case 12: - return burnGeneric[*datacapv12.BurnFromParams, *datacapv12.BurnFromReturn](raw, rawReturn, &datacapv12.BurnFromParams{}, &datacapv12.BurnFromReturn{}) - case 13: - return burnGeneric[*datacapv13.BurnFromParams, *datacapv13.BurnFromReturn](raw, rawReturn, &datacapv13.BurnFromParams{}, &datacapv13.BurnFromReturn{}) - case 14: - return burnGeneric[*datacapv14.BurnFromParams, *datacapv14.BurnFromReturn](raw, rawReturn, &datacapv14.BurnFromParams{}, &datacapv14.BurnFromReturn{}) - case 15: - return burnGeneric[*datacapv15.BurnFromParams, *datacapv15.BurnFromReturn](raw, rawReturn, &datacapv15.BurnFromParams{}, &datacapv15.BurnFromReturn{}) + switch { + case tools.V8.IsSupported(int64(height)): + return parse[*datacapv8.BurnFromParams, *datacapv8.BurnFromReturn](raw, rawReturn, true) + case tools.V9.IsSupported(int64(height)): + return parse[*datacapv9.BurnFromParams, *datacapv9.BurnFromReturn](raw, rawReturn, true) + case tools.V10.IsSupported(int64(height)): + return parse[*datacapv10.BurnFromParams, *datacapv10.BurnFromReturn](raw, rawReturn, true) + case tools.V11.IsSupported(int64(height)): + return parse[*datacapv11.BurnFromParams, *datacapv11.BurnFromReturn](raw, rawReturn, true) + case tools.V12.IsSupported(int64(height)): + return parse[*datacapv12.BurnFromParams, *datacapv12.BurnFromReturn](raw, rawReturn, true) + case tools.V13.IsSupported(int64(height)): + return parse[*datacapv13.BurnFromParams, *datacapv13.BurnFromReturn](raw, rawReturn, true) + case tools.V14.IsSupported(int64(height)): + return parse[*datacapv14.BurnFromParams, *datacapv14.BurnFromReturn](raw, rawReturn, true) + case tools.V15.IsSupported(int64(height)): + return parse[*datacapv15.BurnFromParams, *datacapv15.BurnFromReturn](raw, rawReturn, true) } return nil, fmt.Errorf("not supported") } func DestroyExported(height uint64, raw, rawReturn []byte) (map[string]interface{}, error) { - switch height { - case 9: - return burnGeneric[*datacapv9.DestroyParams, *datacapv9.BurnReturn](raw, rawReturn, &datacapv9.DestroyParams{}, &datacapv9.BurnReturn{}) - case 10: - return burnGeneric[*datacapv10.DestroyParams, *datacapv10.BurnReturn](raw, rawReturn, &datacapv10.DestroyParams{}, &datacapv10.BurnReturn{}) - case 11: - return burnGeneric[*datacapv11.DestroyParams, *datacapv11.BurnReturn](raw, rawReturn, &datacapv11.DestroyParams{}, &datacapv11.BurnReturn{}) - case 12: - return burnGeneric[*datacapv12.DestroyParams, *datacapv12.BurnReturn](raw, rawReturn, &datacapv12.DestroyParams{}, &datacapv12.BurnReturn{}) - case 13: - return burnGeneric[*datacapv13.DestroyParams, *datacapv13.BurnReturn](raw, rawReturn, &datacapv13.DestroyParams{}, &datacapv13.BurnReturn{}) - case 14: - return burnGeneric[*datacapv14.DestroyParams, *datacapv14.BurnReturn](raw, rawReturn, &datacapv14.DestroyParams{}, &datacapv14.BurnReturn{}) - case 15: - return burnGeneric[*datacapv15.DestroyParams, *datacapv15.BurnReturn](raw, rawReturn, &datacapv15.DestroyParams{}, &datacapv15.BurnReturn{}) + switch { + case tools.V8.IsSupported(int64(height)): + return parse[*datacapv8.DestroyParams, *datacapv8.BurnReturn](raw, rawReturn, true) + case tools.V9.IsSupported(int64(height)): + return parse[*datacapv9.DestroyParams, *datacapv9.BurnReturn](raw, rawReturn, true) + case tools.V10.IsSupported(int64(height)): + return parse[*datacapv10.DestroyParams, *datacapv10.BurnReturn](raw, rawReturn, true) + case tools.V11.IsSupported(int64(height)): + return parse[*datacapv11.DestroyParams, *datacapv11.BurnReturn](raw, rawReturn, true) + case tools.V12.IsSupported(int64(height)): + return parse[*datacapv12.DestroyParams, *datacapv12.BurnReturn](raw, rawReturn, true) + case tools.V13.IsSupported(int64(height)): + return parse[*datacapv13.DestroyParams, *datacapv13.BurnReturn](raw, rawReturn, true) + case tools.V14.IsSupported(int64(height)): + return parse[*datacapv14.DestroyParams, *datacapv14.BurnReturn](raw, rawReturn, true) + case tools.V15.IsSupported(int64(height)): + return parse[*datacapv15.DestroyParams, *datacapv15.BurnReturn](raw, rawReturn, true) } return nil, fmt.Errorf("not supported") } diff --git a/actors/datacap/datacap.go b/actors/datacap/datacap.go index ac78936a..4273955a 100644 --- a/actors/datacap/datacap.go +++ b/actors/datacap/datacap.go @@ -1,37 +1,33 @@ package datacap import ( - "bytes" - "io" - "github.com/filecoin-project/go-state-types/abi" "github.com/zondax/fil-parser/parser" ) -type unmarshalCBOR interface { - UnmarshalCBOR(io.Reader) error -} - -func datacapGeneric[T unmarshalCBOR](rawReturn []byte) (map[string]interface{}, error) { - metadata := make(map[string]interface{}) - reader := bytes.NewReader(rawReturn) - var r T - err := r.UnmarshalCBOR(reader) +func NameExported(rawReturn []byte) (map[string]interface{}, error) { + data, err := parse[*abi.CborString, *abi.CborString](nil, rawReturn, false) if err != nil { - return metadata, err + return nil, err } - metadata[parser.ReturnKey] = r - return metadata, nil -} - -func NameExported(rawReturn []byte) (map[string]interface{}, error) { - return datacapGeneric[*abi.CborString](rawReturn) + data[parser.ReturnKey] = data[parser.ParamsKey] + return data, nil } func SymbolExported(rawReturn []byte) (map[string]interface{}, error) { - return datacapGeneric[*abi.CborString](rawReturn) + data, err := parse[*abi.CborString, *abi.CborString](nil, rawReturn, false) + if err != nil { + return nil, err + } + data[parser.ReturnKey] = data[parser.ParamsKey] + return data, nil } func TotalSupplyExported(rawReturn []byte) (map[string]interface{}, error) { - return datacapGeneric[*abi.TokenAmount](rawReturn) + data, err := parse[*abi.TokenAmount, *abi.TokenAmount](nil, rawReturn, false) + if err != nil { + return nil, err + } + data[parser.ReturnKey] = data[parser.ParamsKey] + return data, nil } diff --git a/actors/datacap/generic.go b/actors/datacap/generic.go new file mode 100644 index 00000000..16b0858e --- /dev/null +++ b/actors/datacap/generic.go @@ -0,0 +1,31 @@ +package datacap + +import ( + "bytes" + + "github.com/zondax/fil-parser/parser" +) + +func parse[T datacapParams, R datacapReturn](raw, rawReturn []byte, customReturn bool) (map[string]interface{}, error) { + metadata := make(map[string]interface{}) + reader := bytes.NewReader(raw) + var params T + err := params.UnmarshalCBOR(reader) + if err != nil { + return metadata, err + } + metadata[parser.ParamsKey] = params + + if !customReturn { + return metadata, nil + } + + reader = bytes.NewReader(rawReturn) + var r R + err = r.UnmarshalCBOR(reader) + if err != nil { + return metadata, err + } + metadata[parser.ReturnKey] = r + return metadata, nil +} diff --git a/actors/datacap/granularity.go b/actors/datacap/granularity.go index d7584e59..5a402b1f 100644 --- a/actors/datacap/granularity.go +++ b/actors/datacap/granularity.go @@ -1,53 +1,56 @@ package datacap import ( - "bytes" "fmt" datacapv10 "github.com/filecoin-project/go-state-types/builtin/v10/datacap" datacapv11 "github.com/filecoin-project/go-state-types/builtin/v11/datacap" datacapv12 "github.com/filecoin-project/go-state-types/builtin/v12/datacap" - datacapv13 "github.com/filecoin-project/go-state-types/builtin/v13/datacap" datacapv14 "github.com/filecoin-project/go-state-types/builtin/v14/datacap" datacapv15 "github.com/filecoin-project/go-state-types/builtin/v15/datacap" "github.com/zondax/fil-parser/parser" + "github.com/zondax/fil-parser/tools" ) -type granularityReturn = unmarshalCBOR - -func granularityGeneric[T granularityReturn](rawReturn []byte, r T) (map[string]interface{}, error) { - metadata := make(map[string]interface{}) - reader := bytes.NewReader(rawReturn) - err := r.UnmarshalCBOR(reader) - if err != nil { - return metadata, err - } - metadata[parser.ReturnKey] = r - return metadata, nil -} - -func GranularityExported(height uint64, rawReturn []byte) (map[string]interface{}, error) { - switch height { - case 9: +func GranularityExported(height int64, rawReturn []byte) (map[string]interface{}, error) { + switch { + case tools.V8.IsSupported(height): return nil, fmt.Errorf("not supported") - case 10: - var r datacapv10.GranularityReturn - return granularityGeneric[*datacapv10.GranularityReturn](rawReturn, &r) - case 11: - var r datacapv11.GranularityReturn - return granularityGeneric[*datacapv11.GranularityReturn](rawReturn, &r) - case 12: - var r datacapv12.GranularityReturn - return granularityGeneric[*datacapv12.GranularityReturn](rawReturn, &r) - case 13: - var r datacapv13.GranularityReturn - return granularityGeneric[*datacapv13.GranularityReturn](rawReturn, &r) - case 14: - var r datacapv14.GranularityReturn - return granularityGeneric[*datacapv14.GranularityReturn](rawReturn, &r) - case 15: - var r datacapv15.GranularityReturn - return granularityGeneric[*datacapv15.GranularityReturn](rawReturn, &r) + case tools.V10.IsSupported(height): + data, err := parse[*datacapv10.GranularityReturn, *datacapv10.GranularityReturn](rawReturn, nil, false) + if err != nil { + return nil, err + } + data[parser.ReturnKey] = data[parser.ParamsKey] + return data, nil + case tools.V11.IsSupported(height): + data, err := parse[*datacapv11.GranularityReturn, *datacapv11.GranularityReturn](rawReturn, nil, false) + if err != nil { + return nil, err + } + data[parser.ReturnKey] = data[parser.ParamsKey] + return data, nil + case tools.V12.IsSupported(height): + data, err := parse[*datacapv12.GranularityReturn, *datacapv12.GranularityReturn](rawReturn, nil, false) + if err != nil { + return nil, err + } + data[parser.ReturnKey] = data[parser.ParamsKey] + return data, nil + case tools.V14.IsSupported(height): + data, err := parse[*datacapv14.GranularityReturn, *datacapv14.GranularityReturn](rawReturn, nil, false) + if err != nil { + return nil, err + } + data[parser.ReturnKey] = data[parser.ParamsKey] + return data, nil + case tools.V15.IsSupported(height): + data, err := parse[*datacapv15.GranularityReturn, *datacapv15.GranularityReturn](rawReturn, nil, false) + if err != nil { + return nil, err + } + data[parser.ReturnKey] = data[parser.ParamsKey] + return data, nil } return nil, fmt.Errorf("not supported") } diff --git a/actors/datacap/mint.go b/actors/datacap/mint.go index f31b60e7..23802b66 100644 --- a/actors/datacap/mint.go +++ b/actors/datacap/mint.go @@ -1,7 +1,6 @@ package datacap import ( - "bytes" "fmt" datacapv10 "github.com/filecoin-project/go-state-types/builtin/v10/datacap" @@ -11,7 +10,7 @@ import ( datacapv14 "github.com/filecoin-project/go-state-types/builtin/v14/datacap" datacapv15 "github.com/filecoin-project/go-state-types/builtin/v15/datacap" datacapv9 "github.com/filecoin-project/go-state-types/builtin/v9/datacap" - "github.com/zondax/fil-parser/parser" + "github.com/zondax/fil-parser/tools" ) type ( @@ -19,47 +18,24 @@ type ( mintReturn = unmarshalCBOR ) -func mintGeneric[P mintParams, R mintReturn](raw, rawReturn []byte, params P, r R) (map[string]interface{}, error) { - metadata := make(map[string]interface{}) - reader := bytes.NewReader(raw) - err := params.UnmarshalCBOR(reader) - if err != nil { - return metadata, err - } - metadata[parser.ParamsKey] = params - - reader = bytes.NewReader(rawReturn) - err = r.UnmarshalCBOR(reader) - if err != nil { - return metadata, err - } - metadata[parser.ReturnKey] = r - return metadata, nil -} - -func MintExported(height uint64, raw, rawReturn []byte) (map[string]interface{}, error) { - switch height { - case 9: - var r datacapv9.MintReturn - return mintGeneric[*datacapv9.MintParams, *datacapv9.MintReturn](raw, rawReturn, &datacapv9.MintParams{}, &r) - case 10: - var r datacapv10.MintReturn - return mintGeneric[*datacapv10.MintParams, *datacapv10.MintReturn](raw, rawReturn, &datacapv10.MintParams{}, &r) - case 11: - var r datacapv11.MintReturn - return mintGeneric[*datacapv11.MintParams, *datacapv11.MintReturn](raw, rawReturn, &datacapv11.MintParams{}, &r) - case 12: - var r datacapv12.MintReturn - return mintGeneric[*datacapv12.MintParams, *datacapv12.MintReturn](raw, rawReturn, &datacapv12.MintParams{}, &r) - case 13: - var r datacapv13.MintReturn - return mintGeneric[*datacapv13.MintParams, *datacapv13.MintReturn](raw, rawReturn, &datacapv13.MintParams{}, &r) - case 14: - var r datacapv14.MintReturn - return mintGeneric[*datacapv14.MintParams, *datacapv14.MintReturn](raw, rawReturn, &datacapv14.MintParams{}, &r) - case 15: - var r datacapv15.MintReturn - return mintGeneric[*datacapv15.MintParams, *datacapv15.MintReturn](raw, rawReturn, &datacapv15.MintParams{}, &r) +func MintExported(height int64, raw, rawReturn []byte) (map[string]interface{}, error) { + switch { + case tools.V8.IsSupported(height): + return nil, fmt.Errorf("not supported") + case tools.V9.IsSupported(height): + return parse[*datacapv9.MintParams, *datacapv9.MintReturn](raw, rawReturn, true) + case tools.V10.IsSupported(height): + return parse[*datacapv10.MintParams, *datacapv10.MintReturn](raw, rawReturn, true) + case tools.V11.IsSupported(height): + return parse[*datacapv11.MintParams, *datacapv11.MintReturn](raw, rawReturn, true) + case tools.V12.IsSupported(height): + return parse[*datacapv12.MintParams, *datacapv12.MintReturn](raw, rawReturn, true) + case tools.V13.IsSupported(height): + return parse[*datacapv13.MintParams, *datacapv13.MintReturn](raw, rawReturn, true) + case tools.V14.IsSupported(height): + return parse[*datacapv14.MintParams, *datacapv14.MintReturn](raw, rawReturn, true) + case tools.V15.IsSupported(height): + return parse[*datacapv15.MintParams, *datacapv15.MintReturn](raw, rawReturn, true) } return nil, fmt.Errorf("not supported") } diff --git a/actors/datacap/transfer.go b/actors/datacap/transfer.go index a098fb62..1536258b 100644 --- a/actors/datacap/transfer.go +++ b/actors/datacap/transfer.go @@ -1,7 +1,6 @@ package datacap import ( - "bytes" "fmt" datacapv10 "github.com/filecoin-project/go-state-types/builtin/v10/datacap" @@ -11,50 +10,27 @@ import ( datacapv14 "github.com/filecoin-project/go-state-types/builtin/v14/datacap" datacapv15 "github.com/filecoin-project/go-state-types/builtin/v15/datacap" datacapv9 "github.com/filecoin-project/go-state-types/builtin/v9/datacap" - "github.com/zondax/fil-parser/parser" + "github.com/zondax/fil-parser/tools" ) -type transferParams interface { - unmarshalCBOR -} -type transferReturn interface { - unmarshalCBOR -} - -func transferGeneric[P transferParams, R transferReturn](raw, rawReturn []byte, params P, r R) (map[string]interface{}, error) { - metadata := make(map[string]interface{}) - reader := bytes.NewReader(raw) - err := params.UnmarshalCBOR(reader) - if err != nil { - return metadata, err - } - metadata[parser.ParamsKey] = params - - reader = bytes.NewReader(rawReturn) - err = r.UnmarshalCBOR(reader) - if err != nil { - return metadata, err - } - metadata[parser.ReturnKey] = r - return metadata, nil -} - -func TransferExported(height uint64, raw, rawReturn []byte) (map[string]interface{}, error) { - switch height { - case 9: - return transferGeneric[*datacapv9.TransferParams, *datacapv9.TransferReturn](raw, rawReturn, &datacapv9.TransferParams{}, &datacapv9.TransferReturn{}) - case 10: - return transferGeneric[*datacapv10.TransferParams, *datacapv10.TransferReturn](raw, rawReturn, &datacapv10.TransferParams{}, &datacapv10.TransferReturn{}) - case 11: - return transferGeneric[*datacapv11.TransferParams, *datacapv11.TransferReturn](raw, rawReturn, &datacapv11.TransferParams{}, &datacapv11.TransferReturn{}) - case 12: - return transferGeneric[*datacapv12.TransferParams, *datacapv12.TransferReturn](raw, rawReturn, &datacapv12.TransferParams{}, &datacapv12.TransferReturn{}) - case 13: - return transferGeneric[*datacapv13.TransferParams, *datacapv13.TransferReturn](raw, rawReturn, &datacapv13.TransferParams{}, &datacapv13.TransferReturn{}) - case 14: - return transferGeneric[*datacapv14.TransferParams, *datacapv14.TransferReturn](raw, rawReturn, &datacapv14.TransferParams{}, &datacapv14.TransferReturn{}) - case 15: - return transferGeneric[*datacapv15.TransferParams, *datacapv15.TransferReturn](raw, rawReturn, &datacapv15.TransferParams{}, &datacapv15.TransferReturn{}) +func TransferExported(height int64, raw, rawReturn []byte) (map[string]interface{}, error) { + switch { + case tools.V8.IsSupported(height): + return nil, fmt.Errorf("not supported") + case tools.V9.IsSupported(height): + return parse[*datacapv9.TransferParams, *datacapv9.TransferReturn](raw, rawReturn, true) + case tools.V10.IsSupported(height): + return parse[*datacapv10.TransferParams, *datacapv10.TransferReturn](raw, rawReturn, true) + case tools.V11.IsSupported(height): + return parse[*datacapv11.TransferParams, *datacapv11.TransferReturn](raw, rawReturn, true) + case tools.V12.IsSupported(height): + return parse[*datacapv12.TransferParams, *datacapv12.TransferReturn](raw, rawReturn, true) + case tools.V13.IsSupported(height): + return parse[*datacapv13.TransferParams, *datacapv13.TransferReturn](raw, rawReturn, true) + case tools.V14.IsSupported(height): + return parse[*datacapv14.TransferParams, *datacapv14.TransferReturn](raw, rawReturn, true) + case tools.V15.IsSupported(height): + return parse[*datacapv15.TransferParams, *datacapv15.TransferReturn](raw, rawReturn, true) } return nil, fmt.Errorf("not supported") } diff --git a/actors/datacap/types.go b/actors/datacap/types.go new file mode 100644 index 00000000..b6b24c1f --- /dev/null +++ b/actors/datacap/types.go @@ -0,0 +1,15 @@ +package datacap + +import "io" + +type unmarshalCBOR interface { + UnmarshalCBOR(io.Reader) error +} + +type datacapParams interface { + unmarshalCBOR +} + +type datacapReturn interface { + unmarshalCBOR +} diff --git a/actors/eam/create.go b/actors/eam/create.go index 3afec030..9f91823b 100644 --- a/actors/eam/create.go +++ b/actors/eam/create.go @@ -11,25 +11,26 @@ import ( eamv15 "github.com/filecoin-project/go-state-types/builtin/v15/eam" eamv9 "github.com/filecoin-project/go-state-types/builtin/v9/eam" "github.com/ipfs/go-cid" + "github.com/zondax/fil-parser/tools" "github.com/zondax/fil-parser/types" ) func ParseCreateExternal(height int64, rawParams, rawReturn []byte, msgCid cid.Cid) (map[string]interface{}, *types.AddressInfo, error) { external := true - switch height { - case 15: + switch { + case tools.V15.IsSupported(height): return parseCreate[*eamv15.CreateExternalReturn](rawParams, rawReturn, msgCid, external) - case 14: + case tools.V14.IsSupported(height): return parseCreate[*eamv14.CreateExternalReturn](rawParams, rawReturn, msgCid, external) - case 13: + case tools.V13.IsSupported(height): return parseCreate[*eamv13.CreateExternalReturn](rawParams, rawReturn, msgCid, external) - case 12: + case tools.V12.IsSupported(height): return parseCreate[*eamv12.CreateExternalReturn](rawParams, rawReturn, msgCid, external) - case 11: + case tools.V11.IsSupported(height): return parseCreate[*eamv11.CreateExternalReturn](rawParams, rawReturn, msgCid, external) - case 10: + case tools.V10.IsSupported(height): return parseCreate[*eamv10.CreateExternalReturn](rawParams, rawReturn, msgCid, external) - case 9: + case tools.V9.IsSupported(height): return parseCreate[*eamv9.CreateExternalReturn](rawParams, rawReturn, msgCid, external) } return nil, nil, fmt.Errorf("unsupported height: %d", height) @@ -37,20 +38,20 @@ func ParseCreateExternal(height int64, rawParams, rawReturn []byte, msgCid cid.C func ParseCreate(height int64, rawParams, rawReturn []byte, msgCid cid.Cid) (map[string]interface{}, *types.AddressInfo, error) { external := false - switch height { - case 15: + switch { + case tools.V15.IsSupported(height): return parseCreate[*eamv15.CreateReturn](rawParams, rawReturn, msgCid, external) - case 14: + case tools.V14.IsSupported(height): return parseCreate[*eamv14.CreateReturn](rawParams, rawReturn, msgCid, external) - case 13: + case tools.V13.IsSupported(height): return parseCreate[*eamv13.CreateReturn](rawParams, rawReturn, msgCid, external) - case 12: + case tools.V12.IsSupported(height): return parseCreate[*eamv12.CreateReturn](rawParams, rawReturn, msgCid, external) - case 11: + case tools.V11.IsSupported(height): return parseCreate[*eamv11.CreateReturn](rawParams, rawReturn, msgCid, external) - case 10: + case tools.V10.IsSupported(height): return parseCreate[*eamv10.CreateReturn](rawParams, rawReturn, msgCid, external) - case 9: + case tools.V9.IsSupported(height): return parseCreate[*eamv9.CreateReturn](rawParams, rawReturn, msgCid, external) } return nil, nil, fmt.Errorf("unsupported height: %d", height) @@ -58,20 +59,20 @@ func ParseCreate(height int64, rawParams, rawReturn []byte, msgCid cid.Cid) (map func ParseCreate2(height int64, rawParams, rawReturn []byte, msgCid cid.Cid) (map[string]interface{}, *types.AddressInfo, error) { external := false - switch height { - case 15: + switch { + case tools.V15.IsSupported(height): return parseCreate[*eamv15.Create2Return](rawParams, rawReturn, msgCid, external) - case 14: + case tools.V14.IsSupported(height): return parseCreate[*eamv14.Create2Return](rawParams, rawReturn, msgCid, external) - case 13: + case tools.V13.IsSupported(height): return parseCreate[*eamv13.Create2Return](rawParams, rawReturn, msgCid, external) - case 12: + case tools.V12.IsSupported(height): return parseCreate[*eamv12.Create2Return](rawParams, rawReturn, msgCid, external) - case 11: + case tools.V11.IsSupported(height): return parseCreate[*eamv11.Create2Return](rawParams, rawReturn, msgCid, external) - case 10: + case tools.V10.IsSupported(height): return parseCreate[*eamv10.Create2Return](rawParams, rawReturn, msgCid, external) - case 9: + case tools.V9.IsSupported(height): return parseCreate[*eamv9.Create2Return](rawParams, rawReturn, msgCid, external) } return nil, nil, fmt.Errorf("unsupported height: %d", height) diff --git a/actors/evm/evm.go b/actors/evm/evm.go index 6eb68a89..a150434d 100644 --- a/actors/evm/evm.go +++ b/actors/evm/evm.go @@ -13,6 +13,7 @@ import ( evmv14 "github.com/filecoin-project/go-state-types/builtin/v14/evm" evmv15 "github.com/filecoin-project/go-state-types/builtin/v15/evm" "github.com/zondax/fil-parser/parser" + "github.com/zondax/fil-parser/tools" ) func InvokeContract(rawParams, rawReturn []byte) (map[string]interface{}, error) { @@ -44,44 +45,44 @@ func InvokeContract(rawParams, rawReturn []byte) (map[string]interface{}, error) } func Resurrect(height int64, raw []byte) (map[string]interface{}, error) { - switch height { - case 15: + switch { + case tools.V15.IsSupported(height): return parse[*evmv15.ResurrectParams, *evmv15.ResurrectParams](raw, nil, false) - case 14: + case tools.V14.IsSupported(height): return parse[*evmv14.ResurrectParams, *evmv14.ResurrectParams](raw, nil, false) - case 13: + case tools.V13.IsSupported(height): return parse[*evmv13.ResurrectParams, *evmv13.ResurrectParams](raw, nil, false) - case 12: + case tools.V12.IsSupported(height): return parse[*evmv12.ResurrectParams, *evmv12.ResurrectParams](raw, nil, false) - case 11: + case tools.V11.IsSupported(height): return parse[*evmv11.ResurrectParams, *evmv11.ResurrectParams](raw, nil, false) - case 10: + case tools.V10.IsSupported(height): return parse[*evmv10.ResurrectParams, *evmv10.ResurrectParams](raw, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) } func InvokeContractDelegate(height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { - switch height { - case 15: + switch { + case tools.V15.IsSupported(height): return parse[*evmv15.DelegateCallParams, *abi.CborBytes](rawParams, rawReturn, true) - case 14: + case tools.V14.IsSupported(height): return parse[*evmv14.DelegateCallParams, *abi.CborBytes](rawParams, rawReturn, true) - case 13: + case tools.V13.IsSupported(height): return parse[*evmv13.DelegateCallParams, *abi.CborBytes](rawParams, rawReturn, true) - case 12: + case tools.V12.IsSupported(height): return parse[*evmv12.DelegateCallParams, *abi.CborBytes](rawParams, rawReturn, true) - case 11: + case tools.V11.IsSupported(height): return parse[*evmv11.DelegateCallParams, *abi.CborBytes](rawParams, rawReturn, true) - case 10: + case tools.V10.IsSupported(height): return parse[*evmv10.DelegateCallParams, *abi.CborBytes](rawParams, rawReturn, true) } return nil, fmt.Errorf("unsupported height: %d", height) } func GetByteCode(height int64, raw []byte) (map[string]interface{}, error) { - switch height { - case 15: + switch { + case tools.V15.IsSupported(height): data, err := parse[*evmv15.GetBytecodeReturn, *evmv15.GetBytecodeReturn](raw, nil, false) if err != nil { return nil, err @@ -89,7 +90,7 @@ func GetByteCode(height int64, raw []byte) (map[string]interface{}, error) { // The return value is the same as the params data[parser.ReturnKey] = data[parser.ParamsKey] return data, nil - case 14: + case tools.V14.IsSupported(height): data, err := parse[*evmv14.GetBytecodeReturn, *evmv14.GetBytecodeReturn](raw, nil, false) if err != nil { return nil, err @@ -97,7 +98,7 @@ func GetByteCode(height int64, raw []byte) (map[string]interface{}, error) { // The return value is the same as the params data[parser.ReturnKey] = data[parser.ParamsKey] return data, nil - case 13: + case tools.V13.IsSupported(height): data, err := parse[*evmv13.GetBytecodeReturn, *evmv13.GetBytecodeReturn](raw, nil, false) if err != nil { return nil, err @@ -105,7 +106,7 @@ func GetByteCode(height int64, raw []byte) (map[string]interface{}, error) { // The return value is the same as the params data[parser.ReturnKey] = data[parser.ParamsKey] return data, nil - case 11: + case tools.V11.IsSupported(height): data, err := parse[*evmv11.GetBytecodeReturn, *evmv11.GetBytecodeReturn](raw, nil, false) if err != nil { return nil, err @@ -113,7 +114,7 @@ func GetByteCode(height int64, raw []byte) (map[string]interface{}, error) { // The return value is the same as the params data[parser.ReturnKey] = data[parser.ParamsKey] return data, nil - case 10: + case tools.V10.IsSupported(height): data, err := parse[*evmv10.GetBytecodeReturn, *evmv10.GetBytecodeReturn](raw, nil, false) if err != nil { return nil, err @@ -126,8 +127,8 @@ func GetByteCode(height int64, raw []byte) (map[string]interface{}, error) { } func GetByteCodeHash(height int64, raw []byte) (map[string]interface{}, error) { - switch height { - case 15: + switch { + case tools.V15.IsSupported(height): data, err := parse[*abi.CborBytes, *abi.CborBytes](raw, nil, false) if err != nil { return nil, err @@ -135,7 +136,7 @@ func GetByteCodeHash(height int64, raw []byte) (map[string]interface{}, error) { // The return value is the same as the params data[parser.ReturnKey] = data[parser.ParamsKey] return data, nil - case 14: + case tools.V14.IsSupported(height): data, err := parse[*abi.CborBytes, *abi.CborBytes](raw, nil, false) if err != nil { return nil, err @@ -143,7 +144,7 @@ func GetByteCodeHash(height int64, raw []byte) (map[string]interface{}, error) { // The return value is the same as the params data[parser.ReturnKey] = data[parser.ParamsKey] return data, nil - case 13: + case tools.V13.IsSupported(height): data, err := parse[*abi.CborBytes, *abi.CborBytes](raw, nil, false) if err != nil { return nil, err @@ -151,7 +152,7 @@ func GetByteCodeHash(height int64, raw []byte) (map[string]interface{}, error) { // The return value is the same as the params data[parser.ReturnKey] = data[parser.ParamsKey] return data, nil - case 12: + case tools.V12.IsSupported(height): data, err := parse[*abi.CborBytes, *abi.CborBytes](raw, nil, false) if err != nil { return nil, err @@ -159,7 +160,7 @@ func GetByteCodeHash(height int64, raw []byte) (map[string]interface{}, error) { // The return value is the same as the params data[parser.ReturnKey] = data[parser.ParamsKey] return data, nil - case 11: + case tools.V11.IsSupported(height): data, err := parse[*abi.CborBytes, *abi.CborBytes](raw, nil, false) if err != nil { return nil, err @@ -167,7 +168,7 @@ func GetByteCodeHash(height int64, raw []byte) (map[string]interface{}, error) { // The return value is the same as the params data[parser.ReturnKey] = data[parser.ParamsKey] return data, nil - case 10: + case tools.V10.IsSupported(height): data, err := parse[*abi.CborBytes, *abi.CborBytes](raw, nil, false) if err != nil { return nil, err @@ -180,36 +181,36 @@ func GetByteCodeHash(height int64, raw []byte) (map[string]interface{}, error) { } func EVMConstructor(height int64, raw []byte) (map[string]interface{}, error) { - switch height { - case 15: + switch { + case tools.V15.IsSupported(height): return parse[*evmv15.ConstructorParams, *evmv15.ConstructorParams](raw, nil, false) - case 14: + case tools.V14.IsSupported(height): return parse[*evmv14.ConstructorParams, *evmv14.ConstructorParams](raw, nil, false) - case 13: + case tools.V13.IsSupported(height): return parse[*evmv13.ConstructorParams, *evmv13.ConstructorParams](raw, nil, false) - case 12: + case tools.V12.IsSupported(height): return parse[*evmv12.ConstructorParams, *evmv12.ConstructorParams](raw, nil, false) - case 11: + case tools.V11.IsSupported(height): return parse[*evmv11.ConstructorParams, *evmv11.ConstructorParams](raw, nil, false) - case 10: + case tools.V10.IsSupported(height): return parse[*evmv10.ConstructorParams, *evmv10.ConstructorParams](raw, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) } func GetStorageAt(height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { - switch height { - case 15: + switch { + case tools.V15.IsSupported(height): return parse[*evmv15.GetStorageAtParams, *abi.CborBytes](rawParams, rawReturn, true) - case 14: + case tools.V14.IsSupported(height): return parse[*evmv14.GetStorageAtParams, *abi.CborBytes](rawParams, rawReturn, true) - case 13: + case tools.V13.IsSupported(height): return parse[*evmv13.GetStorageAtParams, *abi.CborBytes](rawParams, rawReturn, true) - case 12: + case tools.V12.IsSupported(height): return parse[*evmv12.GetStorageAtParams, *abi.CborBytes](rawParams, rawReturn, true) - case 11: + case tools.V11.IsSupported(height): return parse[*evmv11.GetStorageAtParams, *abi.CborBytes](rawParams, rawReturn, true) - case 10: + case tools.V10.IsSupported(height): return parse[*evmv10.GetStorageAtParams, *abi.CborBytes](rawParams, rawReturn, true) } return nil, fmt.Errorf("unsupported height: %d", height) diff --git a/actors/init/init.go b/actors/init/init.go index 42c7f8d1..7c62d157 100644 --- a/actors/init/init.go +++ b/actors/init/init.go @@ -16,6 +16,7 @@ import ( "github.com/ipfs/go-cid" "github.com/zondax/fil-parser/parser" + "github.com/zondax/fil-parser/tools" "github.com/zondax/fil-parser/types" ) @@ -79,66 +80,66 @@ func returnParams(msg *parser.LotusMessage, actorCID string, params execReturn) } func InitConstructor(height int64, raw []byte) (map[string]interface{}, error) { - switch height { - case 15: + switch { + case tools.V15.IsSupported(height): return initConstructor[*builtinInitv15.ConstructorParams](raw) - case 14: + case tools.V14.IsSupported(height): return initConstructor[*builtinInitv14.ConstructorParams](raw) - case 13: + case tools.V13.IsSupported(height): return initConstructor[*builtinInitv13.ConstructorParams](raw) - case 12: + case tools.V12.IsSupported(height): return initConstructor[*builtinInitv12.ConstructorParams](raw) - case 11: + case tools.V11.IsSupported(height): return initConstructor[*builtinInitv11.ConstructorParams](raw) - case 10: + case tools.V10.IsSupported(height): return initConstructor[*builtinInitv10.ConstructorParams](raw) - case 9: + case tools.V9.IsSupported(height): return initConstructor[*builtinInitv9.ConstructorParams](raw) - case 8: + case tools.V8.IsSupported(height): return initConstructor[*builtinInitv8.ConstructorParams](raw) } return nil, fmt.Errorf("unsupported height: %d", height) } func ParseExec(height int64, msg *parser.LotusMessage, raw []byte) (map[string]interface{}, *types.AddressInfo, error) { - switch height { - case 15: + switch { + case tools.V15.IsSupported(height): return parseExec[*builtinInitv15.ExecParams, *builtinInitv15.ExecReturn](msg, raw) - case 14: + case tools.V14.IsSupported(height): return parseExec[*builtinInitv14.ExecParams, *builtinInitv14.ExecReturn](msg, raw) - case 13: + case tools.V13.IsSupported(height): return parseExec[*builtinInitv13.ExecParams, *builtinInitv13.ExecReturn](msg, raw) - case 12: + case tools.V12.IsSupported(height): return parseExec[*builtinInitv12.ExecParams, *builtinInitv12.ExecReturn](msg, raw) - case 11: + case tools.V11.IsSupported(height): return parseExec[*builtinInitv11.ExecParams, *builtinInitv11.ExecReturn](msg, raw) - case 10: + case tools.V10.IsSupported(height): return parseExec[*builtinInitv10.ExecParams, *builtinInitv10.ExecReturn](msg, raw) - case 9: + case tools.V9.IsSupported(height): return parseExec[*builtinInitv9.ExecParams, *builtinInitv9.ExecReturn](msg, raw) - case 8: + case tools.V8.IsSupported(height): return parseExec[*builtinInitv8.ExecParams, *builtinInitv8.ExecReturn](msg, raw) } return nil, nil, fmt.Errorf("unsupported height: %d", height) } func ParseExec4(height int64, msg *parser.LotusMessage, raw []byte) (map[string]interface{}, *types.AddressInfo, error) { - switch height { - case 15: + switch { + case tools.V15.IsSupported(height): return parseExec[*builtinInitv15.Exec4Params, *builtinInitv15.Exec4Return](msg, raw) - case 14: + case tools.V14.IsSupported(height): return parseExec[*builtinInitv14.Exec4Params, *builtinInitv14.Exec4Return](msg, raw) - case 13: + case tools.V13.IsSupported(height): return parseExec[*builtinInitv13.Exec4Params, *builtinInitv13.Exec4Return](msg, raw) - case 12: + case tools.V12.IsSupported(height): return parseExec[*builtinInitv12.Exec4Params, *builtinInitv12.Exec4Return](msg, raw) - case 11: + case tools.V11.IsSupported(height): return parseExec[*builtinInitv11.Exec4Params, *builtinInitv11.Exec4Return](msg, raw) - case 10: + case tools.V10.IsSupported(height): return parseExec[*builtinInitv10.Exec4Params, *builtinInitv10.Exec4Return](msg, raw) - case 9: + case tools.V9.IsSupported(height): return nil, nil, fmt.Errorf("unsupported height: %d", height) - case 8: + case tools.V8.IsSupported(height): return nil, nil, fmt.Errorf("unsupported height: %d", height) } return nil, nil, fmt.Errorf("unsupported height: %d", height) diff --git a/actors/market/market.go b/actors/market/market.go index fbbbbb06..47497b0b 100644 --- a/actors/market/market.go +++ b/actors/market/market.go @@ -12,394 +12,394 @@ import ( v15Market "github.com/filecoin-project/go-state-types/builtin/v15/market" v8Market "github.com/filecoin-project/go-state-types/builtin/v8/market" v9Market "github.com/filecoin-project/go-state-types/builtin/v9/market" + "github.com/zondax/fil-parser/tools" ) func ParseAddBalance(height int64, rawParams []byte) (map[string]interface{}, error) { - switch height { - case 15: + switch { + case tools.V15.IsSupported(height): return parseGeneric[*address.Address, *address.Address](rawParams, nil, false) - case 14: + case tools.V14.IsSupported(height): return parseGeneric[*address.Address, *address.Address](rawParams, nil, false) - case 13: + case tools.V13.IsSupported(height): return parseGeneric[*address.Address, *address.Address](rawParams, nil, false) - case 12: + case tools.V12.IsSupported(height): return parseGeneric[*address.Address, *address.Address](rawParams, nil, false) - case 11: + case tools.V11.IsSupported(height): return parseGeneric[*address.Address, *address.Address](rawParams, nil, false) - case 10: + case tools.V10.IsSupported(height): return parseGeneric[*address.Address, *address.Address](rawParams, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) } func ParseWithdrawBalance(height int64, rawParams []byte) (map[string]interface{}, error) { - switch height { - case 15: + switch { + case tools.V15.IsSupported(height): return parseGeneric[*v15Market.WithdrawBalanceParams, *v15Market.WithdrawBalanceParams](rawParams, nil, false) - case 14: + case tools.V14.IsSupported(height): return parseGeneric[*v14Market.WithdrawBalanceParams, *v14Market.WithdrawBalanceParams](rawParams, nil, false) - case 13: + case tools.V13.IsSupported(height): return parseGeneric[*v13Market.WithdrawBalanceParams, *v13Market.WithdrawBalanceParams](rawParams, nil, false) - case 12: + case tools.V12.IsSupported(height): return parseGeneric[*v12Market.WithdrawBalanceParams, *v12Market.WithdrawBalanceParams](rawParams, nil, false) - case 11: + case tools.V11.IsSupported(height): return parseGeneric[*v11Market.WithdrawBalanceParams, *v11Market.WithdrawBalanceParams](rawParams, nil, false) - case 10: + case tools.V10.IsSupported(height): return parseGeneric[*v10Market.WithdrawBalanceParams, *v10Market.WithdrawBalanceParams](rawParams, nil, false) - case 9: + case tools.V9.IsSupported(height): return parseGeneric[*v9Market.WithdrawBalanceParams, *v9Market.WithdrawBalanceParams](rawParams, nil, false) - case 8: + case tools.V8.IsSupported(height): return parseGeneric[*v8Market.WithdrawBalanceParams, *v8Market.WithdrawBalanceParams](rawParams, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) } func PublishStorageDealsParams(height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { - switch height { - case 15: + switch { + case tools.V15.IsSupported(height): return parseGeneric[*v15Market.PublishStorageDealsParams, *v15Market.PublishStorageDealsReturn](rawParams, rawReturn, true) - case 14: + case tools.V14.IsSupported(height): return parseGeneric[*v14Market.PublishStorageDealsParams, *v14Market.PublishStorageDealsReturn](rawParams, rawReturn, true) - case 13: + case tools.V13.IsSupported(height): return parseGeneric[*v13Market.PublishStorageDealsParams, *v13Market.PublishStorageDealsReturn](rawParams, rawReturn, true) - case 12: + case tools.V12.IsSupported(height): return parseGeneric[*v12Market.PublishStorageDealsParams, *v12Market.PublishStorageDealsReturn](rawParams, rawReturn, true) - case 11: + case tools.V11.IsSupported(height): return parseGeneric[*v11Market.PublishStorageDealsParams, *v11Market.PublishStorageDealsReturn](rawParams, rawReturn, true) - case 10: + case tools.V10.IsSupported(height): return parseGeneric[*v10Market.PublishStorageDealsParams, *v10Market.PublishStorageDealsReturn](rawParams, rawReturn, true) - case 9: + case tools.V9.IsSupported(height): return parseGeneric[*v9Market.PublishStorageDealsParams, *v9Market.PublishStorageDealsReturn](rawParams, rawReturn, true) - case 8: + case tools.V8.IsSupported(height): return parseGeneric[*v8Market.PublishStorageDealsParams, *v8Market.PublishStorageDealsReturn](rawParams, rawReturn, true) } return nil, fmt.Errorf("unsupported height: %d", height) } func VerifyDealsForActivationParams(height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { - switch height { - case 15: + switch { + case tools.V15.IsSupported(height): return parseGeneric[*v15Market.VerifyDealsForActivationParams, *v15Market.VerifyDealsForActivationReturn](rawParams, rawReturn, true) - case 14: + case tools.V14.IsSupported(height): return parseGeneric[*v14Market.VerifyDealsForActivationParams, *v14Market.VerifyDealsForActivationReturn](rawParams, rawReturn, true) - case 13: + case tools.V13.IsSupported(height): return parseGeneric[*v13Market.VerifyDealsForActivationParams, *v13Market.VerifyDealsForActivationReturn](rawParams, rawReturn, true) - case 12: + case tools.V12.IsSupported(height): return parseGeneric[*v12Market.VerifyDealsForActivationParams, *v12Market.VerifyDealsForActivationReturn](rawParams, rawReturn, true) - case 11: + case tools.V11.IsSupported(height): return parseGeneric[*v11Market.VerifyDealsForActivationParams, *v11Market.VerifyDealsForActivationReturn](rawParams, rawReturn, true) - case 10: + case tools.V10.IsSupported(height): return parseGeneric[*v10Market.VerifyDealsForActivationParams, *v10Market.VerifyDealsForActivationReturn](rawParams, rawReturn, true) - case 9: + case tools.V9.IsSupported(height): return parseGeneric[*v9Market.VerifyDealsForActivationParams, *v9Market.VerifyDealsForActivationReturn](rawParams, rawReturn, true) - case 8: + case tools.V8.IsSupported(height): return parseGeneric[*v8Market.VerifyDealsForActivationParams, *v8Market.VerifyDealsForActivationReturn](rawParams, rawReturn, true) } return nil, fmt.Errorf("unsupported height: %d", height) } func ActivateDealsParams(height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { - switch height { - case 15: + switch { + case tools.V15.IsSupported(height): return parseGeneric[*v15Market.ActivateDealsParams, *v15Market.ActivateDealsResult](rawParams, rawReturn, true) - case 14: + case tools.V14.IsSupported(height): return parseGeneric[*v14Market.ActivateDealsParams, *v14Market.ActivateDealsResult](rawParams, rawReturn, true) - case 13: + case tools.V13.IsSupported(height): return parseGeneric[*v13Market.ActivateDealsParams, *v13Market.ActivateDealsResult](rawParams, rawReturn, true) - case 12: + case tools.V12.IsSupported(height): return parseGeneric[*v12Market.ActivateDealsParams, *v12Market.ActivateDealsResult](rawParams, rawReturn, true) - case 11: + case tools.V11.IsSupported(height): return parseGeneric[*v11Market.ActivateDealsParams, *v11Market.ActivateDealsResult](rawParams, rawReturn, true) - case 10: + case tools.V10.IsSupported(height): return parseGeneric[*v10Market.ActivateDealsParams, *v10Market.ActivateDealsResult](rawParams, rawReturn, true) - case 9: + case tools.V9.IsSupported(height): return parseGeneric[*v9Market.ActivateDealsParams, *v9Market.ActivateDealsResult](rawParams, rawReturn, true) - case 8: - // return parseGeneric[*v8Market.ActivateDealsParams, *v8Market.ActivateDealsResult](rawParams, rawReturn, true) + // case 8: // This case is commented out in the original code + // return parseGeneric[*v8Market.ActivateDealsParams, *v8Market.ActivateDealsResult](rawParams, rawReturn, true) } return nil, fmt.Errorf("unsupported height: %d", height) } func OnMinerSectorsTerminateParams(height int64, rawParams []byte) (map[string]interface{}, error) { - switch height { - case 15: + switch { + case tools.V15.IsSupported(height): return parseGeneric[*v15Market.OnMinerSectorsTerminateParams, *v15Market.OnMinerSectorsTerminateParams](rawParams, nil, false) - case 14: + case tools.V14.IsSupported(height): return parseGeneric[*v14Market.OnMinerSectorsTerminateParams, *v14Market.OnMinerSectorsTerminateParams](rawParams, nil, false) - case 13: + case tools.V13.IsSupported(height): return parseGeneric[*v13Market.OnMinerSectorsTerminateParams, *v13Market.OnMinerSectorsTerminateParams](rawParams, nil, false) - case 12: + case tools.V12.IsSupported(height): return parseGeneric[*v12Market.OnMinerSectorsTerminateParams, *v12Market.OnMinerSectorsTerminateParams](rawParams, nil, false) - case 11: + case tools.V11.IsSupported(height): return parseGeneric[*v11Market.OnMinerSectorsTerminateParams, *v11Market.OnMinerSectorsTerminateParams](rawParams, nil, false) - case 10: + case tools.V10.IsSupported(height): return parseGeneric[*v10Market.OnMinerSectorsTerminateParams, *v10Market.OnMinerSectorsTerminateParams](rawParams, nil, false) - case 9: + case tools.V9.IsSupported(height): return parseGeneric[*v9Market.OnMinerSectorsTerminateParams, *v9Market.OnMinerSectorsTerminateParams](rawParams, nil, false) - case 8: + case tools.V8.IsSupported(height): return parseGeneric[*v8Market.OnMinerSectorsTerminateParams, *v8Market.OnMinerSectorsTerminateParams](rawParams, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) } func ComputeDataCommitmentParams(height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { - switch height { - case 15: - // return parseGeneric[*v15Market.ComputeDataCommitmentParams, *v15Market.ComputeDataCommitmentReturn](rawParams, rawReturn, true) - case 14: - // return parseGeneric[*v14Market.ComputeDataCommitmentParams, *v14Market.ComputeDataCommitmentReturn](rawParams, rawReturn, true) - case 13: - // return parseGeneric[*v13Market.ComputeDataCommitmentParams, *v13Market.ComputeDataCommitmentReturn](rawParams, rawReturn, true) - case 12: - // return parseGeneric[*v12Market.ComputeDataCommitmentParams, *v12Market.ComputeDataCommitmentReturn](rawParams, rawReturn, true) - case 11: + switch { + // case 15: // These cases are commented out in the original code + // return parseGeneric[*v15Market.ComputeDataCommitmentParams, *v15Market.ComputeDataCommitmentReturn](rawParams, rawReturn, true) + // case 14: + // return parseGeneric[*v14Market.ComputeDataCommitmentParams, *v14Market.ComputeDataCommitmentReturn](rawParams, rawReturn, true) + // case 13: + // return parseGeneric[*v13Market.ComputeDataCommitmentParams, *v13Market.ComputeDataCommitmentReturn](rawParams, rawReturn, true) + // case 12: + // return parseGeneric[*v12Market.ComputeDataCommitmentParams, *v12Market.ComputeDataCommitmentReturn](rawParams, rawReturn, true) + case tools.V11.IsSupported(height): return parseGeneric[*v11Market.ComputeDataCommitmentParams, *v11Market.ComputeDataCommitmentReturn](rawParams, rawReturn, true) - case 10: + case tools.V10.IsSupported(height): return parseGeneric[*v10Market.ComputeDataCommitmentParams, *v10Market.ComputeDataCommitmentReturn](rawParams, rawReturn, true) - case 9: + case tools.V9.IsSupported(height): return parseGeneric[*v9Market.ComputeDataCommitmentParams, *v9Market.ComputeDataCommitmentReturn](rawParams, rawReturn, true) - case 8: + case tools.V8.IsSupported(height): return parseGeneric[*v8Market.ComputeDataCommitmentParams, *v8Market.ComputeDataCommitmentReturn](rawParams, rawReturn, true) } return nil, fmt.Errorf("unsupported height: %d", height) } func GetBalanceParams(height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { - switch height { - case 15: + switch { + case tools.V15.IsSupported(height): return parseGeneric[*address.Address, *v15Market.GetBalanceReturn](rawParams, rawReturn, true) - case 14: + case tools.V14.IsSupported(height): return parseGeneric[*address.Address, *v14Market.GetBalanceReturn](rawParams, rawReturn, true) - case 13: + case tools.V13.IsSupported(height): return parseGeneric[*address.Address, *v13Market.GetBalanceReturn](rawParams, rawReturn, true) - case 12: + case tools.V12.IsSupported(height): return parseGeneric[*address.Address, *v12Market.GetBalanceReturn](rawParams, rawReturn, true) - case 11: + case tools.V11.IsSupported(height): return parseGeneric[*address.Address, *v11Market.GetBalanceReturn](rawParams, rawReturn, true) - case 10: + case tools.V10.IsSupported(height): return parseGeneric[*address.Address, *v10Market.GetBalanceReturn](rawParams, rawReturn, true) - case 9: - // return parseGeneric[*address.Address, *v9Market.GetBalanceReturn](rawParams, rawReturn, true) - case 8: - // return parseGeneric[*address.Address, *v8Market.GetBalanceReturn](rawParams, rawReturn, true) + // case 9: // These cases are commented out in the original code + // return parseGeneric[*address.Address, *v9Market.GetBalanceReturn](rawParams, rawReturn, true) + // case 8: + // return parseGeneric[*address.Address, *v8Market.GetBalanceReturn](rawParams, rawReturn, true) } return nil, fmt.Errorf("unsupported height: %d", height) } func GetDealDataCommitmentParams(height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { - switch height { - case 15: + switch { + case tools.V15.IsSupported(height): return parseGeneric[*v15Market.GetDealDataCommitmentParams, *v15Market.GetDealDataCommitmentReturn](rawParams, rawReturn, true) - case 14: + case tools.V14.IsSupported(height): return parseGeneric[*v14Market.GetDealDataCommitmentParams, *v14Market.GetDealDataCommitmentReturn](rawParams, rawReturn, true) - case 13: + case tools.V13.IsSupported(height): return parseGeneric[*v13Market.GetDealDataCommitmentParams, *v13Market.GetDealDataCommitmentReturn](rawParams, rawReturn, true) - case 12: + case tools.V12.IsSupported(height): return parseGeneric[*v12Market.GetDealDataCommitmentParams, *v12Market.GetDealDataCommitmentReturn](rawParams, rawReturn, true) - case 11: + case tools.V11.IsSupported(height): return parseGeneric[*v11Market.GetDealDataCommitmentParams, *v11Market.GetDealDataCommitmentReturn](rawParams, rawReturn, true) - case 10: + case tools.V10.IsSupported(height): return parseGeneric[*v10Market.GetDealDataCommitmentParams, *v10Market.GetDealDataCommitmentReturn](rawParams, rawReturn, true) - case 9: - // return parseGeneric[*v9Market.GetDealDataCommitmentParams, *v9Market.GetDealDataCommitmentReturn](rawParams, rawReturn, true) - case 8: - // return parseGeneric[*v8Market.GetDealDataCommitmentParams, *v8Market.GetDealDataCommitmentReturn](rawParams, rawReturn, true) + // case 9: // These cases are commented out in the original code + // return parseGeneric[*v9Market.GetDealDataCommitmentParams, *v9Market.GetDealDataCommitmentReturn](rawParams, rawReturn, true) + // case 8: + // return parseGeneric[*v8Market.GetDealDataCommitmentParams, *v8Market.GetDealDataCommitmentReturn](rawParams, rawReturn, true) } return nil, fmt.Errorf("unsupported height: %d", height) } func GetDealClientParams(height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { - switch height { - case 15: + switch { + case tools.V15.IsSupported(height): return parseGeneric[*v15Market.GetDealClientParams, *v15Market.GetDealClientReturn](rawParams, rawReturn, true) - case 14: + case tools.V14.IsSupported(height): return parseGeneric[*v14Market.GetDealClientParams, *v14Market.GetDealClientReturn](rawParams, rawReturn, true) - case 13: + case tools.V13.IsSupported(height): return parseGeneric[*v13Market.GetDealClientParams, *v13Market.GetDealClientReturn](rawParams, rawReturn, true) - case 12: + case tools.V12.IsSupported(height): return parseGeneric[*v12Market.GetDealClientParams, *v12Market.GetDealClientReturn](rawParams, rawReturn, true) - case 11: + case tools.V11.IsSupported(height): return parseGeneric[*v11Market.GetDealClientParams, *v11Market.GetDealClientReturn](rawParams, rawReturn, true) - case 10: + case tools.V10.IsSupported(height): return parseGeneric[*v10Market.GetDealClientParams, *v10Market.GetDealClientReturn](rawParams, rawReturn, true) - case 9: - // return parseGeneric[*v9Market.GetDealClientParams, *v9Market.GetDealClientReturn](rawParams, rawReturn, true) - case 8: - // return parseGeneric[*v8Market.GetDealClientParams, *v8Market.GetDealClientReturn](rawParams, rawReturn, true) + // case 9: // These cases are commented out in the original code + // return parseGeneric[*v9Market.GetDealClientParams, *v9Market.GetDealClientReturn](rawParams, rawReturn, true) + // case 8: + // return parseGeneric[*v8Market.GetDealClientParams, *v8Market.GetDealClientReturn](rawParams, rawReturn, true) } return nil, fmt.Errorf("unsupported height: %d", height) } func GetDealProviderParams(height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { - switch height { - case 15: + switch { + case tools.V15.IsSupported(height): return parseGeneric[*v15Market.GetDealProviderParams, *v15Market.GetDealProviderReturn](rawParams, rawReturn, true) - case 14: + case tools.V14.IsSupported(height): return parseGeneric[*v14Market.GetDealProviderParams, *v14Market.GetDealProviderReturn](rawParams, rawReturn, true) - case 13: + case tools.V13.IsSupported(height): return parseGeneric[*v13Market.GetDealProviderParams, *v13Market.GetDealProviderReturn](rawParams, rawReturn, true) - case 12: + case tools.V12.IsSupported(height): return parseGeneric[*v12Market.GetDealProviderParams, *v12Market.GetDealProviderReturn](rawParams, rawReturn, true) - case 11: + case tools.V11.IsSupported(height): return parseGeneric[*v11Market.GetDealProviderParams, *v11Market.GetDealProviderReturn](rawParams, rawReturn, true) - case 10: + case tools.V10.IsSupported(height): return parseGeneric[*v10Market.GetDealProviderParams, *v10Market.GetDealProviderReturn](rawParams, rawReturn, true) - case 9: - // return parseGeneric[*v9Market.GetDealProviderParams, *v9Market.GetDealProviderReturn](rawParams, rawReturn, true) - case 8: - // return parseGeneric[*v8Market.GetDealProviderParams, *v8Market.GetDealProviderReturn](rawParams, rawReturn, true) + // case 9: // These cases are commented out in the original code + // return parseGeneric[*v9Market.GetDealProviderParams, *v9Market.GetDealProviderReturn](rawParams, rawReturn, true) + // case 8: + // return parseGeneric[*v8Market.GetDealProviderParams, *v8Market.GetDealProviderReturn](rawParams, rawReturn, true) } return nil, fmt.Errorf("unsupported height: %d", height) } func GetDealLabelParams(height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { - switch height { - case 15: + switch { + case tools.V15.IsSupported(height): return parseGeneric[*v15Market.GetDealLabelParams, *v15Market.GetDealLabelReturn](rawParams, rawReturn, true) - case 14: + case tools.V14.IsSupported(height): return parseGeneric[*v14Market.GetDealLabelParams, *v14Market.GetDealLabelReturn](rawParams, rawReturn, true) - case 13: + case tools.V13.IsSupported(height): return parseGeneric[*v13Market.GetDealLabelParams, *v13Market.GetDealLabelReturn](rawParams, rawReturn, true) - case 12: + case tools.V12.IsSupported(height): return parseGeneric[*v12Market.GetDealLabelParams, *v12Market.GetDealLabelReturn](rawParams, rawReturn, true) - case 11: + case tools.V11.IsSupported(height): return parseGeneric[*v11Market.GetDealLabelParams, *v11Market.GetDealLabelReturn](rawParams, rawReturn, true) - case 10: + case tools.V10.IsSupported(height): return parseGeneric[*v10Market.GetDealLabelParams, *v10Market.GetDealLabelReturn](rawParams, rawReturn, true) - case 9: - // return parseGeneric[*v9Market.GetDealLabelParams, *v9Market.GetDealLabelReturn](rawParams, rawReturn, true) - case 8: - // return parseGeneric[*v8Market.GetDealLabelParams, *v8Market.GetDealLabelReturn](rawParams, rawReturn, true) + // case 9: // These cases are commented out in the original code + // return parseGeneric[*v9Market.GetDealLabelParams, *v9Market.GetDealLabelReturn](rawParams, rawReturn, true) + // case 8: + // return parseGeneric[*v8Market.GetDealLabelParams, *v8Market.GetDealLabelReturn](rawParams, rawReturn, true) } return nil, fmt.Errorf("unsupported height: %d", height) } func GetDealTermParams(height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { - switch height { - case 15: + switch { + case tools.V15.IsSupported(height): return parseGeneric[*v15Market.GetDealTermParams, *v15Market.GetDealTermReturn](rawParams, rawReturn, true) - case 14: + case tools.V14.IsSupported(height): return parseGeneric[*v14Market.GetDealTermParams, *v14Market.GetDealTermReturn](rawParams, rawReturn, true) - case 13: + case tools.V13.IsSupported(height): return parseGeneric[*v13Market.GetDealTermParams, *v13Market.GetDealTermReturn](rawParams, rawReturn, true) - case 12: + case tools.V12.IsSupported(height): return parseGeneric[*v12Market.GetDealTermParams, *v12Market.GetDealTermReturn](rawParams, rawReturn, true) - case 11: + case tools.V11.IsSupported(height): return parseGeneric[*v11Market.GetDealTermParams, *v11Market.GetDealTermReturn](rawParams, rawReturn, true) - case 10: + case tools.V10.IsSupported(height): return parseGeneric[*v10Market.GetDealTermParams, *v10Market.GetDealTermReturn](rawParams, rawReturn, true) - case 9: - // return parseGeneric[*v9Market.GetDealTermParams, *v9Market.GetDealTermReturn](rawParams, rawReturn, true) - case 8: - // return parseGeneric[*v8Market.GetDealTermParams, *v8Market.GetDealTermReturn](rawParams, rawReturn, true) + // case 9: // These cases are commented out in the original code + // return parseGeneric[*v9Market.GetDealTermParams, *v9Market.GetDealTermReturn](rawParams, rawReturn, true) + // case 8: + // return parseGeneric[*v8Market.GetDealTermParams, *v8Market.GetDealTermReturn](rawParams, rawReturn, true) } return nil, fmt.Errorf("unsupported height: %d", height) } func GetDealTotalPriceParams(height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { - switch height { - case 15: + switch { + case tools.V15.IsSupported(height): return parseGeneric[*v15Market.GetDealTotalPriceParams, *v15Market.GetDealTotalPriceReturn](rawParams, rawReturn, true) - case 14: + case tools.V14.IsSupported(height): return parseGeneric[*v14Market.GetDealTotalPriceParams, *v14Market.GetDealTotalPriceReturn](rawParams, rawReturn, true) - case 13: + case tools.V13.IsSupported(height): return parseGeneric[*v13Market.GetDealTotalPriceParams, *v13Market.GetDealTotalPriceReturn](rawParams, rawReturn, true) - case 12: + case tools.V12.IsSupported(height): return parseGeneric[*v12Market.GetDealTotalPriceParams, *v12Market.GetDealTotalPriceReturn](rawParams, rawReturn, true) - case 11: + case tools.V11.IsSupported(height): return parseGeneric[*v11Market.GetDealTotalPriceParams, *v11Market.GetDealTotalPriceReturn](rawParams, rawReturn, true) - case 10: + case tools.V10.IsSupported(height): return parseGeneric[*v10Market.GetDealTotalPriceParams, *v10Market.GetDealTotalPriceReturn](rawParams, rawReturn, true) - case 9: - // return parseGeneric[*v9Market.GetDealTotalPriceParams, *v9Market.GetDealTotalPriceReturn](rawParams, rawReturn, true) - case 8: - // return parseGeneric[*v8Market.GetDealTotalPriceParams, *v8Market.GetDealTotalPriceReturn](rawParams, rawReturn, true) + // case 9: // These cases are commented out in the original code + // return parseGeneric[*v9Market.GetDealTotalPriceParams, *v9Market.GetDealTotalPriceReturn](rawParams, rawReturn, true) + // case 8: + // return parseGeneric[*v8Market.GetDealTotalPriceParams, *v8Market.GetDealTotalPriceReturn](rawParams, rawReturn, true) } return nil, fmt.Errorf("unsupported height: %d", height) } func GetDealClientCollateralParams(height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { - switch height { - case 15: + switch { + case tools.V15.IsSupported(height): return parseGeneric[*v15Market.GetDealClientCollateralParams, *v15Market.GetDealClientCollateralReturn](rawParams, rawReturn, true) - case 14: + case tools.V14.IsSupported(height): return parseGeneric[*v14Market.GetDealClientCollateralParams, *v14Market.GetDealClientCollateralReturn](rawParams, rawReturn, true) - case 13: + case tools.V13.IsSupported(height): return parseGeneric[*v13Market.GetDealClientCollateralParams, *v13Market.GetDealClientCollateralReturn](rawParams, rawReturn, true) - case 12: + case tools.V12.IsSupported(height): return parseGeneric[*v12Market.GetDealClientCollateralParams, *v12Market.GetDealClientCollateralReturn](rawParams, rawReturn, true) - case 11: + case tools.V11.IsSupported(height): return parseGeneric[*v11Market.GetDealClientCollateralParams, *v11Market.GetDealClientCollateralReturn](rawParams, rawReturn, true) - case 10: + case tools.V10.IsSupported(height): return parseGeneric[*v10Market.GetDealClientCollateralParams, *v10Market.GetDealClientCollateralReturn](rawParams, rawReturn, true) - case 9: - // return parseGeneric[*v9Market.GetDealClientCollateralParams, *v9Market.GetDealClientCollateralReturn](rawParams, rawReturn, true) - case 8: - // return parseGeneric[*v8Market.GetDealClientCollateralParams, *v8Market.GetDealClientCollateralReturn](rawParams, rawReturn, true) + // case 9: // These cases are commented out in the original code + // return parseGeneric[*v9Market.GetDealClientCollateralParams, *v9Market.GetDealClientCollateralReturn](rawParams, rawReturn, true) + // case 8: + // return parseGeneric[*v8Market.GetDealClientCollateralParams, *v8Market.GetDealClientCollateralReturn](rawParams, rawReturn, true) } return nil, fmt.Errorf("unsupported height: %d", height) } func GetDealProviderCollateralParams(height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { - switch height { - case 15: + switch { + case tools.V15.IsSupported(height): return parseGeneric[*v15Market.GetDealProviderCollateralParams, *v15Market.GetDealProviderCollateralReturn](rawParams, rawReturn, true) - case 14: + case tools.V14.IsSupported(height): return parseGeneric[*v14Market.GetDealProviderCollateralParams, *v14Market.GetDealProviderCollateralReturn](rawParams, rawReturn, true) - case 13: + case tools.V13.IsSupported(height): return parseGeneric[*v13Market.GetDealProviderCollateralParams, *v13Market.GetDealProviderCollateralReturn](rawParams, rawReturn, true) - case 12: + case tools.V12.IsSupported(height): return parseGeneric[*v12Market.GetDealProviderCollateralParams, *v12Market.GetDealProviderCollateralReturn](rawParams, rawReturn, true) - case 11: + case tools.V11.IsSupported(height): return parseGeneric[*v11Market.GetDealProviderCollateralParams, *v11Market.GetDealProviderCollateralReturn](rawParams, rawReturn, true) - case 10: + case tools.V10.IsSupported(height): return parseGeneric[*v10Market.GetDealProviderCollateralParams, *v10Market.GetDealProviderCollateralReturn](rawParams, rawReturn, true) - case 9: - // return parseGeneric[*v9Market.GetDealProviderCollateralParams, *v9Market.GetDealProviderCollateralReturn](rawParams, rawReturn, true) - case 8: - // return parseGeneric[*v8Market.GetDealProviderCollateralParams, *v8Market.GetDealProviderCollateralReturn](rawParams, rawReturn, true) + // case 9: // These cases are commented out in the original code + // return parseGeneric[*v9Market.GetDealProviderCollateralParams, *v9Market.GetDealProviderCollateralReturn](rawParams, rawReturn, true) + // case 8: + // return parseGeneric[*v8Market.GetDealProviderCollateralParams, *v8Market.GetDealProviderCollateralReturn](rawParams, rawReturn, true) } return nil, fmt.Errorf("unsupported height: %d", height) } func GetDealVerifiedParams(height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { - switch height { - case 15: + switch { + case tools.V15.IsSupported(height): return parseGeneric[*v15Market.GetDealVerifiedParams, *v15Market.GetDealVerifiedReturn](rawParams, rawReturn, true) - case 14: + case tools.V14.IsSupported(height): return parseGeneric[*v14Market.GetDealVerifiedParams, *v14Market.GetDealVerifiedReturn](rawParams, rawReturn, true) - case 13: + case tools.V13.IsSupported(height): return parseGeneric[*v13Market.GetDealVerifiedParams, *v13Market.GetDealVerifiedReturn](rawParams, rawReturn, true) - case 12: + case tools.V12.IsSupported(height): return parseGeneric[*v12Market.GetDealVerifiedParams, *v12Market.GetDealVerifiedReturn](rawParams, rawReturn, true) - case 11: + case tools.V11.IsSupported(height): return parseGeneric[*v11Market.GetDealVerifiedParams, *v11Market.GetDealVerifiedReturn](rawParams, rawReturn, true) - case 10: + case tools.V10.IsSupported(height): return parseGeneric[*v10Market.GetDealVerifiedParams, *v10Market.GetDealVerifiedReturn](rawParams, rawReturn, true) - case 9: - // return parseGeneric[*v9Market.GetDealVerifiedParams, *v9Market.GetDealVerifiedReturn](rawParams, rawReturn, true) - case 8: - // return parseGeneric[*v8Market.GetDealVerifiedParams, *v8Market.GetDealVerifiedReturn](rawParams, rawReturn, true) + // case 9: // These cases are commented out in the original code + // return parseGeneric[*v9Market.GetDealVerifiedParams, *v9Market.GetDealVerifiedReturn](rawParams, rawReturn, true) + // case 8: + // return parseGeneric[*v8Market.GetDealVerifiedParams, *v8Market.GetDealVerifiedReturn](rawParams, rawReturn, true) } return nil, fmt.Errorf("unsupported height: %d", height) } func GetDealActivationParams(height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { - switch height { - case 15: + switch { + case tools.V15.IsSupported(height): return parseGeneric[*v15Market.GetDealActivationParams, *v15Market.GetDealActivationReturn](rawParams, rawReturn, true) - case 14: + case tools.V14.IsSupported(height): return parseGeneric[*v14Market.GetDealActivationParams, *v14Market.GetDealActivationReturn](rawParams, rawReturn, true) - case 13: + case tools.V13.IsSupported(height): return parseGeneric[*v13Market.GetDealActivationParams, *v13Market.GetDealActivationReturn](rawParams, rawReturn, true) - case 12: + case tools.V12.IsSupported(height): return parseGeneric[*v12Market.GetDealActivationParams, *v12Market.GetDealActivationReturn](rawParams, rawReturn, true) - case 11: + case tools.V11.IsSupported(height): return parseGeneric[*v11Market.GetDealActivationParams, *v11Market.GetDealActivationReturn](rawParams, rawReturn, true) - case 10: + case tools.V10.IsSupported(height): return parseGeneric[*v10Market.GetDealActivationParams, *v10Market.GetDealActivationReturn](rawParams, rawReturn, true) - case 9: - // return parseGeneric[*v9Market.GetDealActivationParams, *v9Market.GetDealActivationReturn](rawParams, rawReturn, true) - case 8: - // return parseGeneric[*v8Market.GetDealActivationParams, *v8Market.GetDealActivationReturn](rawParams, rawReturn, true) + // case 9: // These cases are commented out in the original code + // return parseGeneric[*v9Market.GetDealActivationParams, *v9Market.GetDealActivationReturn](rawParams, rawReturn, true) + // case 8: } return nil, fmt.Errorf("unsupported height: %d", height) } diff --git a/actors/miner/address.go b/actors/miner/address.go index e5dbb946..b99e56fd 100644 --- a/actors/miner/address.go +++ b/actors/miner/address.go @@ -4,69 +4,189 @@ import ( "fmt" "github.com/filecoin-project/go-address" + miner10 "github.com/filecoin-project/go-state-types/builtin/v10/miner" + miner11 "github.com/filecoin-project/go-state-types/builtin/v11/miner" + miner12 "github.com/filecoin-project/go-state-types/builtin/v12/miner" + miner13 "github.com/filecoin-project/go-state-types/builtin/v13/miner" + miner14 "github.com/filecoin-project/go-state-types/builtin/v14/miner" miner15 "github.com/filecoin-project/go-state-types/builtin/v15/miner" + miner8 "github.com/filecoin-project/go-state-types/builtin/v8/miner" + miner9 "github.com/filecoin-project/go-state-types/builtin/v9/miner" + "github.com/zondax/fil-parser/tools" ) func ChangeMultiaddrs(height int64, rawParams []byte) (map[string]interface{}, error) { - switch height { - case 15: + switch { + case tools.V15.IsSupported(height): return parseGeneric[*miner15.ChangeMultiaddrsParams, *miner15.ChangeMultiaddrsParams](rawParams, nil, false) + case tools.V14.IsSupported(height): + return parseGeneric[*miner14.ChangeMultiaddrsParams, *miner14.ChangeMultiaddrsParams](rawParams, nil, false) + case tools.V13.IsSupported(height): + return parseGeneric[*miner13.ChangeMultiaddrsParams, *miner13.ChangeMultiaddrsParams](rawParams, nil, false) + case tools.V12.IsSupported(height): + return parseGeneric[*miner12.ChangeMultiaddrsParams, *miner12.ChangeMultiaddrsParams](rawParams, nil, false) + case tools.V11.IsSupported(height): + return parseGeneric[*miner11.ChangeMultiaddrsParams, *miner11.ChangeMultiaddrsParams](rawParams, nil, false) + case tools.V10.IsSupported(height): + return parseGeneric[*miner10.ChangeMultiaddrsParams, *miner10.ChangeMultiaddrsParams](rawParams, nil, false) + case tools.V9.IsSupported(height): + return parseGeneric[*miner9.ChangeMultiaddrsParams, *miner9.ChangeMultiaddrsParams](rawParams, nil, false) + case tools.V8.IsSupported(height): + return parseGeneric[*miner8.ChangeMultiaddrsParams, *miner8.ChangeMultiaddrsParams](rawParams, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) } func ChangePeerID(height int64, rawParams []byte) (map[string]interface{}, error) { - switch height { - case 15: + switch { + case tools.V15.IsSupported(height): return parseGeneric[*miner15.ChangePeerIDParams, *miner15.ChangePeerIDParams](rawParams, nil, false) + case tools.V14.IsSupported(height): + return parseGeneric[*miner14.ChangePeerIDParams, *miner14.ChangePeerIDParams](rawParams, nil, false) + case tools.V13.IsSupported(height): + return parseGeneric[*miner13.ChangePeerIDParams, *miner13.ChangePeerIDParams](rawParams, nil, false) + case tools.V12.IsSupported(height): + return parseGeneric[*miner12.ChangePeerIDParams, *miner12.ChangePeerIDParams](rawParams, nil, false) + case tools.V11.IsSupported(height): + return parseGeneric[*miner11.ChangePeerIDParams, *miner11.ChangePeerIDParams](rawParams, nil, false) + case tools.V10.IsSupported(height): + return parseGeneric[*miner10.ChangePeerIDParams, *miner10.ChangePeerIDParams](rawParams, nil, false) + case tools.V9.IsSupported(height): + return parseGeneric[*miner9.ChangePeerIDParams, *miner9.ChangePeerIDParams](rawParams, nil, false) + case tools.V8.IsSupported(height): + return parseGeneric[*miner8.ChangePeerIDParams, *miner8.ChangePeerIDParams](rawParams, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) } func ChangeWorkerAddress(height int64, rawParams []byte) (map[string]interface{}, error) { - switch height { - case 15: + switch { + case tools.V15.IsSupported(height): return parseGeneric[*miner15.ChangeWorkerAddressParams, *miner15.ChangeWorkerAddressParams](rawParams, nil, false) + case tools.V14.IsSupported(height): + return parseGeneric[*miner14.ChangeWorkerAddressParams, *miner14.ChangeWorkerAddressParams](rawParams, nil, false) + case tools.V13.IsSupported(height): + return parseGeneric[*miner13.ChangeWorkerAddressParams, *miner13.ChangeWorkerAddressParams](rawParams, nil, false) + case tools.V12.IsSupported(height): + return parseGeneric[*miner12.ChangeWorkerAddressParams, *miner12.ChangeWorkerAddressParams](rawParams, nil, false) + case tools.V11.IsSupported(height): + return parseGeneric[*miner11.ChangeWorkerAddressParams, *miner11.ChangeWorkerAddressParams](rawParams, nil, false) + case tools.V10.IsSupported(height): + return parseGeneric[*miner10.ChangeWorkerAddressParams, *miner10.ChangeWorkerAddressParams](rawParams, nil, false) + case tools.V9.IsSupported(height): + return parseGeneric[*miner9.ChangeWorkerAddressParams, *miner9.ChangeWorkerAddressParams](rawParams, nil, false) + case tools.V8.IsSupported(height): + return parseGeneric[*miner8.ChangeWorkerAddressParams, *miner8.ChangeWorkerAddressParams](rawParams, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) } func ChangeOwnerAddress(height int64, rawParams []byte) (map[string]interface{}, error) { - switch height { - case 15: + switch { + case tools.V15.IsSupported(height): + return parseGeneric[*address.Address, *address.Address](rawParams, nil, false) + case tools.V14.IsSupported(height): + return parseGeneric[*address.Address, *address.Address](rawParams, nil, false) + case tools.V13.IsSupported(height): + return parseGeneric[*address.Address, *address.Address](rawParams, nil, false) + case tools.V12.IsSupported(height): + return parseGeneric[*address.Address, *address.Address](rawParams, nil, false) + case tools.V11.IsSupported(height): + return parseGeneric[*address.Address, *address.Address](rawParams, nil, false) + case tools.V10.IsSupported(height): + return parseGeneric[*address.Address, *address.Address](rawParams, nil, false) + case tools.V9.IsSupported(height): + return parseGeneric[*address.Address, *address.Address](rawParams, nil, false) + case tools.V8.IsSupported(height): return parseGeneric[*address.Address, *address.Address](rawParams, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) } func IsControllingAddressExported(height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { - switch height { - case 15: + switch { + case tools.V15.IsSupported(height): return parseGeneric[*miner15.IsControllingAddressParams, *miner15.IsControllingAddressReturn](rawParams, rawReturn, true) + case tools.V14.IsSupported(height): + return parseGeneric[*miner14.IsControllingAddressParams, *miner14.IsControllingAddressReturn](rawParams, rawReturn, true) + case tools.V13.IsSupported(height): + return parseGeneric[*miner13.IsControllingAddressParams, *miner13.IsControllingAddressReturn](rawParams, rawReturn, true) + case tools.V12.IsSupported(height): + return parseGeneric[*miner12.IsControllingAddressParams, *miner12.IsControllingAddressReturn](rawParams, rawReturn, true) + case tools.V11.IsSupported(height): + return parseGeneric[*miner11.IsControllingAddressParams, *miner11.IsControllingAddressReturn](rawParams, rawReturn, true) + case tools.V10.IsSupported(height): + return parseGeneric[*miner10.IsControllingAddressParams, *miner10.IsControllingAddressReturn](rawParams, rawReturn, true) + case tools.V9.IsSupported(height): + return parseGeneric[*miner9.IsControllingAddressParams, *miner9.IsControllingAddressReturn](rawParams, rawReturn, true) + case tools.V8.IsSupported(height): + return parseGeneric[*miner8.IsControllingAddressParams, *miner8.IsControllingAddressReturn](rawParams, rawReturn, true) } return nil, fmt.Errorf("unsupported height: %d", height) } func GetOwner(height int64, rawReturn []byte) (map[string]interface{}, error) { - switch height { - case 15: + switch { + case tools.V15.IsSupported(height): return parseGeneric[*miner15.GetOwnerReturn, *miner15.GetOwnerReturn](rawReturn, nil, false) + case tools.V14.IsSupported(height): + return parseGeneric[*miner14.GetOwnerReturn, *miner14.GetOwnerReturn](rawReturn, nil, false) + case tools.V13.IsSupported(height): + return parseGeneric[*miner13.GetOwnerReturn, *miner13.GetOwnerReturn](rawReturn, nil, false) + case tools.V12.IsSupported(height): + return parseGeneric[*miner12.GetOwnerReturn, *miner12.GetOwnerReturn](rawReturn, nil, false) + case tools.V11.IsSupported(height): + return parseGeneric[*miner11.GetOwnerReturn, *miner11.GetOwnerReturn](rawReturn, nil, false) + case tools.V10.IsSupported(height): + return parseGeneric[*miner10.GetOwnerReturn, *miner10.GetOwnerReturn](rawReturn, nil, false) + case tools.V9.IsSupported(height): + return parseGeneric[*miner9.GetOwnerReturn, *miner9.GetOwnerReturn](rawReturn, nil, false) + case tools.V8.IsSupported(height): + return parseGeneric[*miner8.GetOwnerReturn, *miner8.GetOwnerReturn](rawReturn, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) } func GetPeerID(height int64, rawReturn []byte) (map[string]interface{}, error) { - switch height { - case 15: + switch { + case tools.V15.IsSupported(height): return parseGeneric[*miner15.GetPeerIDReturn, *miner15.GetPeerIDReturn](rawReturn, nil, false) + case tools.V14.IsSupported(height): + return parseGeneric[*miner14.GetPeerIDReturn, *miner14.GetPeerIDReturn](rawReturn, nil, false) + case tools.V13.IsSupported(height): + return parseGeneric[*miner13.GetPeerIDReturn, *miner13.GetPeerIDReturn](rawReturn, nil, false) + case tools.V12.IsSupported(height): + return parseGeneric[*miner12.GetPeerIDReturn, *miner12.GetPeerIDReturn](rawReturn, nil, false) + case tools.V11.IsSupported(height): + return parseGeneric[*miner11.GetPeerIDReturn, *miner11.GetPeerIDReturn](rawReturn, nil, false) + case tools.V10.IsSupported(height): + return parseGeneric[*miner10.GetPeerIDReturn, *miner10.GetPeerIDReturn](rawReturn, nil, false) + case tools.V9.IsSupported(height): + return parseGeneric[*miner9.GetPeerIDReturn, *miner9.GetPeerIDReturn](rawReturn, nil, false) + case tools.V8.IsSupported(height): + return parseGeneric[*miner8.GetPeerIDReturn, *miner8.GetPeerIDReturn](rawReturn, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) } func GetMultiaddrs(height int64, rawReturn []byte) (map[string]interface{}, error) { - switch height { - case 15: + switch { + case tools.V15.IsSupported(height): return parseGeneric[*miner15.GetMultiAddrsReturn, *miner15.GetMultiAddrsReturn](rawReturn, nil, false) + case tools.V14.IsSupported(height): + return parseGeneric[*miner14.GetMultiAddrsReturn, *miner14.GetMultiAddrsReturn](rawReturn, nil, false) + case tools.V13.IsSupported(height): + return parseGeneric[*miner13.GetMultiAddrsReturn, *miner13.GetMultiAddrsReturn](rawReturn, nil, false) + case tools.V12.IsSupported(height): + return parseGeneric[*miner12.GetMultiAddrsReturn, *miner12.GetMultiAddrsReturn](rawReturn, nil, false) + case tools.V11.IsSupported(height): + return parseGeneric[*miner11.GetMultiAddrsReturn, *miner11.GetMultiAddrsReturn](rawReturn, nil, false) + case tools.V10.IsSupported(height): + return parseGeneric[*miner10.GetMultiAddrsReturn, *miner10.GetMultiAddrsReturn](rawReturn, nil, false) + case tools.V9.IsSupported(height): + return parseGeneric[*miner9.GetMultiAddrsReturn, *miner9.GetMultiAddrsReturn](rawReturn, nil, false) + case tools.V8.IsSupported(height): + return parseGeneric[*miner8.GetMultiAddrsReturn, *miner8.GetMultiAddrsReturn](rawReturn, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) } diff --git a/actors/miner/balance.go b/actors/miner/balance.go index 75d3b282..f03fb986 100644 --- a/actors/miner/balance.go +++ b/actors/miner/balance.go @@ -3,29 +3,79 @@ package miner import ( "fmt" + miner10 "github.com/filecoin-project/go-state-types/builtin/v10/miner" + miner11 "github.com/filecoin-project/go-state-types/builtin/v11/miner" + miner12 "github.com/filecoin-project/go-state-types/builtin/v12/miner" + miner13 "github.com/filecoin-project/go-state-types/builtin/v13/miner" + miner14 "github.com/filecoin-project/go-state-types/builtin/v14/miner" miner15 "github.com/filecoin-project/go-state-types/builtin/v15/miner" + miner8 "github.com/filecoin-project/go-state-types/builtin/v8/miner" + miner9 "github.com/filecoin-project/go-state-types/builtin/v9/miner" + "github.com/zondax/fil-parser/tools" ) func GetAvailableBalance(height int64, rawReturn []byte) (map[string]interface{}, error) { - switch height { - case 15: + switch { + case tools.V15.IsSupported(height): return parseGeneric[*miner15.GetAvailableBalanceReturn, *miner15.GetAvailableBalanceReturn](rawReturn, nil, false) + case tools.V14.IsSupported(height): + return parseGeneric[*miner14.GetAvailableBalanceReturn, *miner14.GetAvailableBalanceReturn](rawReturn, nil, false) + case tools.V13.IsSupported(height): + return parseGeneric[*miner13.GetAvailableBalanceReturn, *miner13.GetAvailableBalanceReturn](rawReturn, nil, false) + case tools.V12.IsSupported(height): + return parseGeneric[*miner12.GetAvailableBalanceReturn, *miner12.GetAvailableBalanceReturn](rawReturn, nil, false) + case tools.V11.IsSupported(height): + return parseGeneric[*miner11.GetAvailableBalanceReturn, *miner11.GetAvailableBalanceReturn](rawReturn, nil, false) + case tools.V10.IsSupported(height): + return parseGeneric[*miner10.GetAvailableBalanceReturn, *miner10.GetAvailableBalanceReturn](rawReturn, nil, false) + case tools.V9.IsSupported(height): + return parseGeneric[*miner9.GetAvailableBalanceReturn, *miner9.GetAvailableBalanceReturn](rawReturn, nil, false) + case tools.V8.IsSupported(height): + return parseGeneric[*miner8.GetAvailableBalanceReturn, *miner8.GetAvailableBalanceReturn](rawReturn, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) } func GetVestingFunds(height int64, rawReturn []byte) (map[string]interface{}, error) { - switch height { - case 15: + switch { + case tools.V15.IsSupported(height): return parseGeneric[*miner15.GetVestingFundsReturn, *miner15.GetVestingFundsReturn](rawReturn, nil, false) + case tools.V14.IsSupported(height): + return parseGeneric[*miner14.GetVestingFundsReturn, *miner14.GetVestingFundsReturn](rawReturn, nil, false) + case tools.V13.IsSupported(height): + return parseGeneric[*miner13.GetVestingFundsReturn, *miner13.GetVestingFundsReturn](rawReturn, nil, false) + case tools.V12.IsSupported(height): + return parseGeneric[*miner12.GetVestingFundsReturn, *miner12.GetVestingFundsReturn](rawReturn, nil, false) + case tools.V11.IsSupported(height): + return parseGeneric[*miner11.GetVestingFundsReturn, *miner11.GetVestingFundsReturn](rawReturn, nil, false) + case tools.V10.IsSupported(height): + return parseGeneric[*miner10.GetVestingFundsReturn, *miner10.GetVestingFundsReturn](rawReturn, nil, false) + case tools.V9.IsSupported(height): + return parseGeneric[*miner9.GetVestingFundsReturn, *miner9.GetVestingFundsReturn](rawReturn, nil, false) + case tools.V8.IsSupported(height): + return parseGeneric[*miner8.GetVestingFundsReturn, *miner8.GetVestingFundsReturn](rawReturn, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) } func ParseWithdrawBalance(height int64, rawParams []byte) (map[string]interface{}, error) { - switch height { - case 15: + switch { + case tools.V15.IsSupported(height): return parseGeneric[*miner15.WithdrawBalanceParams, *miner15.WithdrawBalanceParams](rawParams, nil, false) + case tools.V14.IsSupported(height): + return parseGeneric[*miner14.WithdrawBalanceParams, *miner14.WithdrawBalanceParams](rawParams, nil, false) + case tools.V13.IsSupported(height): + return parseGeneric[*miner13.WithdrawBalanceParams, *miner13.WithdrawBalanceParams](rawParams, nil, false) + case tools.V12.IsSupported(height): + return parseGeneric[*miner12.WithdrawBalanceParams, *miner12.WithdrawBalanceParams](rawParams, nil, false) + case tools.V11.IsSupported(height): + return parseGeneric[*miner11.WithdrawBalanceParams, *miner11.WithdrawBalanceParams](rawParams, nil, false) + case tools.V10.IsSupported(height): + return parseGeneric[*miner10.WithdrawBalanceParams, *miner10.WithdrawBalanceParams](rawParams, nil, false) + case tools.V9.IsSupported(height): + return parseGeneric[*miner9.WithdrawBalanceParams, *miner9.WithdrawBalanceParams](rawParams, nil, false) + case tools.V8.IsSupported(height): + return parseGeneric[*miner8.WithdrawBalanceParams, *miner8.WithdrawBalanceParams](rawParams, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) } diff --git a/actors/miner/miner.go b/actors/miner/miner.go index 5b77a39f..e52fd789 100644 --- a/actors/miner/miner.go +++ b/actors/miner/miner.go @@ -11,192 +11,291 @@ import ( miner15 "github.com/filecoin-project/go-state-types/builtin/v15/miner" miner8 "github.com/filecoin-project/go-state-types/builtin/v8/miner" miner9 "github.com/filecoin-project/go-state-types/builtin/v9/miner" + "github.com/zondax/fil-parser/tools" ) func TerminateSectors(height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { - switch height { - case 15: + switch { + case tools.V15.IsSupported(height): return parseGeneric[*miner15.TerminateSectorsParams, *miner15.TerminateSectorsReturn](rawParams, rawReturn, true) - case 14: + case tools.V14.IsSupported(height): return parseGeneric[*miner14.TerminateSectorsParams, *miner14.TerminateSectorsReturn](rawParams, rawReturn, true) - case 13: + case tools.V13.IsSupported(height): return parseGeneric[*miner13.TerminateSectorsParams, *miner13.TerminateSectorsReturn](rawParams, rawReturn, true) - case 12: + case tools.V12.IsSupported(height): return parseGeneric[*miner12.TerminateSectorsParams, *miner12.TerminateSectorsReturn](rawParams, rawReturn, true) - case 11: + case tools.V11.IsSupported(height): return parseGeneric[*miner11.TerminateSectorsParams, *miner11.TerminateSectorsReturn](rawParams, rawReturn, true) - case 10: + case tools.V10.IsSupported(height): return parseGeneric[*miner10.TerminateSectorsParams, *miner10.TerminateSectorsReturn](rawParams, rawReturn, true) - case 9: + case tools.V9.IsSupported(height): return parseGeneric[*miner9.TerminateSectorsParams, *miner9.TerminateSectorsReturn](rawParams, rawReturn, true) - case 8: + case tools.V8.IsSupported(height): return parseGeneric[*miner8.TerminateSectorsParams, *miner8.TerminateSectorsReturn](rawParams, rawReturn, true) } return nil, fmt.Errorf("unsupported height: %d", height) } func DeclareFaults(height int64, rawParams []byte) (map[string]interface{}, error) { - switch height { - case 15: + switch { + case tools.V15.IsSupported(height): return parseGeneric[*miner15.DeclareFaultsParams, *miner15.DeclareFaultsParams](rawParams, nil, false) - case 14: + case tools.V14.IsSupported(height): return parseGeneric[*miner14.DeclareFaultsParams, *miner14.DeclareFaultsParams](rawParams, nil, false) - case 13: + case tools.V13.IsSupported(height): return parseGeneric[*miner13.DeclareFaultsParams, *miner13.DeclareFaultsParams](rawParams, nil, false) - case 12: + case tools.V12.IsSupported(height): return parseGeneric[*miner12.DeclareFaultsParams, *miner12.DeclareFaultsParams](rawParams, nil, false) - case 11: + case tools.V11.IsSupported(height): return parseGeneric[*miner11.DeclareFaultsParams, *miner11.DeclareFaultsParams](rawParams, nil, false) - case 10: + case tools.V10.IsSupported(height): return parseGeneric[*miner10.DeclareFaultsParams, *miner10.DeclareFaultsParams](rawParams, nil, false) - case 9: + case tools.V9.IsSupported(height): return parseGeneric[*miner9.DeclareFaultsParams, *miner9.DeclareFaultsParams](rawParams, nil, false) - case 8: + case tools.V8.IsSupported(height): return parseGeneric[*miner8.DeclareFaultsParams, *miner8.DeclareFaultsParams](rawParams, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) } func DeclareFaultsRecovered(height int64, rawParams []byte) (map[string]interface{}, error) { - switch height { - case 15: + switch { + case tools.V15.IsSupported(height): return parseGeneric[*miner15.DeclareFaultsRecoveredParams, *miner15.DeclareFaultsRecoveredParams](rawParams, nil, false) - case 14: + case tools.V14.IsSupported(height): return parseGeneric[*miner14.DeclareFaultsRecoveredParams, *miner14.DeclareFaultsRecoveredParams](rawParams, nil, false) - case 13: + case tools.V13.IsSupported(height): return parseGeneric[*miner13.DeclareFaultsRecoveredParams, *miner13.DeclareFaultsRecoveredParams](rawParams, nil, false) - case 12: + case tools.V12.IsSupported(height): return parseGeneric[*miner12.DeclareFaultsRecoveredParams, *miner12.DeclareFaultsRecoveredParams](rawParams, nil, false) - case 11: + case tools.V11.IsSupported(height): return parseGeneric[*miner11.DeclareFaultsRecoveredParams, *miner11.DeclareFaultsRecoveredParams](rawParams, nil, false) - case 10: + case tools.V10.IsSupported(height): return parseGeneric[*miner10.DeclareFaultsRecoveredParams, *miner10.DeclareFaultsRecoveredParams](rawParams, nil, false) - case 9: + case tools.V9.IsSupported(height): return parseGeneric[*miner9.DeclareFaultsRecoveredParams, *miner9.DeclareFaultsRecoveredParams](rawParams, nil, false) - case 8: + case tools.V8.IsSupported(height): return parseGeneric[*miner8.DeclareFaultsRecoveredParams, *miner8.DeclareFaultsRecoveredParams](rawParams, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) } func ProveReplicaUpdates(height int64, rawParams []byte) (map[string]interface{}, error) { - switch height { - case 15: + switch { + case tools.V15.IsSupported(height): return parseGeneric[*miner15.ProveReplicaUpdatesParams, *miner15.ProveReplicaUpdatesParams](rawParams, nil, false) - case 14: + case tools.V14.IsSupported(height): return parseGeneric[*miner14.ProveReplicaUpdatesParams, *miner14.ProveReplicaUpdatesParams](rawParams, nil, false) - case 13: + case tools.V13.IsSupported(height): return parseGeneric[*miner13.ProveReplicaUpdatesParams, *miner13.ProveReplicaUpdatesParams](rawParams, nil, false) - case 12: + case tools.V12.IsSupported(height): return parseGeneric[*miner12.ProveReplicaUpdatesParams, *miner12.ProveReplicaUpdatesParams](rawParams, nil, false) - case 11: + case tools.V11.IsSupported(height): return parseGeneric[*miner11.ProveReplicaUpdatesParams, *miner11.ProveReplicaUpdatesParams](rawParams, nil, false) - case 10: + case tools.V10.IsSupported(height): return parseGeneric[*miner10.ProveReplicaUpdatesParams, *miner10.ProveReplicaUpdatesParams](rawParams, nil, false) - case 9: + case tools.V9.IsSupported(height): return parseGeneric[*miner9.ProveReplicaUpdatesParams, *miner9.ProveReplicaUpdatesParams](rawParams, nil, false) - case 8: + case tools.V8.IsSupported(height): return parseGeneric[*miner8.ProveReplicaUpdatesParams, *miner8.ProveReplicaUpdatesParams](rawParams, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) } func PreCommitSectorBatch2(height int64, rawParams []byte) (map[string]interface{}, error) { - switch height { - case 15: + switch { + case tools.V15.IsSupported(height): return parseGeneric[*miner15.PreCommitSectorBatchParams2, *miner15.PreCommitSectorBatchParams2](rawParams, nil, false) - case 14: + case tools.V14.IsSupported(height): return parseGeneric[*miner14.PreCommitSectorBatchParams2, *miner14.PreCommitSectorBatchParams2](rawParams, nil, false) - case 13: + case tools.V13.IsSupported(height): return parseGeneric[*miner13.PreCommitSectorBatchParams2, *miner13.PreCommitSectorBatchParams2](rawParams, nil, false) - case 12: + case tools.V12.IsSupported(height): return parseGeneric[*miner12.PreCommitSectorBatchParams2, *miner12.PreCommitSectorBatchParams2](rawParams, nil, false) - case 11: + case tools.V11.IsSupported(height): return parseGeneric[*miner11.PreCommitSectorBatchParams2, *miner11.PreCommitSectorBatchParams2](rawParams, nil, false) - case 10: + case tools.V10.IsSupported(height): return parseGeneric[*miner10.PreCommitSectorBatchParams2, *miner10.PreCommitSectorBatchParams2](rawParams, nil, false) - case 9: + case tools.V9.IsSupported(height): return parseGeneric[*miner9.PreCommitSectorBatchParams2, *miner9.PreCommitSectorBatchParams2](rawParams, nil, false) - case 8: - // return parseGeneric[*miner8.PreCommitSectorBatchParams2, *miner8.PreCommitSectorBatchParams2](rawParams, nil, false) + case tools.V8.IsSupported(height): + return nil, fmt.Errorf("unsupported height: %d", height) } return nil, fmt.Errorf("unsupported height: %d", height) } func ProveReplicaUpdates2(height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { - switch height { - case 15: + switch { + case tools.V15.IsSupported(height): return parseGeneric[*miner15.ProveReplicaUpdatesParams2, *miner15.ProveReplicaUpdatesParams2](rawParams, rawReturn, true) - case 14: + case tools.V14.IsSupported(height): return parseGeneric[*miner14.ProveReplicaUpdatesParams2, *miner14.ProveReplicaUpdatesParams2](rawParams, rawReturn, true) - case 13: + case tools.V13.IsSupported(height): return parseGeneric[*miner13.ProveReplicaUpdatesParams2, *miner13.ProveReplicaUpdatesParams2](rawParams, rawReturn, true) - case 12: + case tools.V12.IsSupported(height): return parseGeneric[*miner12.ProveReplicaUpdatesParams2, *miner12.ProveReplicaUpdatesParams2](rawParams, rawReturn, true) - case 11: + case tools.V11.IsSupported(height): return parseGeneric[*miner11.ProveReplicaUpdatesParams2, *miner11.ProveReplicaUpdatesParams2](rawParams, rawReturn, true) - case 10: + case tools.V10.IsSupported(height): return parseGeneric[*miner10.ProveReplicaUpdatesParams2, *miner10.ProveReplicaUpdatesParams2](rawParams, rawReturn, true) - case 9: + case tools.V9.IsSupported(height): return parseGeneric[*miner9.ProveReplicaUpdatesParams2, *miner9.ProveReplicaUpdatesParams2](rawParams, rawReturn, true) - case 8: - // return parseGeneric[*miner8.ProveReplicaUpdatesParams2, *miner8.ProveReplicaUpdatesParams2](rawParams, rawReturn, true) + case tools.V8.IsSupported(height): + return nil, fmt.Errorf("unsupported height: %d", height) } return nil, fmt.Errorf("unsupported height: %d", height) } func ProveCommitAggregate(height int64, rawParams []byte) (map[string]interface{}, error) { - switch height { - case 15: + switch { + case tools.V15.IsSupported(height): return parseGeneric[*miner15.ProveCommitAggregateParams, *miner15.ProveCommitAggregateParams](rawParams, nil, false) + case tools.V14.IsSupported(height): + return parseGeneric[*miner14.ProveCommitAggregateParams, *miner14.ProveCommitAggregateParams](rawParams, nil, false) + case tools.V13.IsSupported(height): + return parseGeneric[*miner13.ProveCommitAggregateParams, *miner13.ProveCommitAggregateParams](rawParams, nil, false) + case tools.V12.IsSupported(height): + return parseGeneric[*miner12.ProveCommitAggregateParams, *miner12.ProveCommitAggregateParams](rawParams, nil, false) + case tools.V11.IsSupported(height): + return parseGeneric[*miner11.ProveCommitAggregateParams, *miner11.ProveCommitAggregateParams](rawParams, nil, false) + case tools.V10.IsSupported(height): + return parseGeneric[*miner10.ProveCommitAggregateParams, *miner10.ProveCommitAggregateParams](rawParams, nil, false) + case tools.V9.IsSupported(height): + return parseGeneric[*miner9.ProveCommitAggregateParams, *miner9.ProveCommitAggregateParams](rawParams, nil, false) + case tools.V8.IsSupported(height): + return parseGeneric[*miner8.ProveCommitAggregateParams, *miner8.ProveCommitAggregateParams](rawParams, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) } func DisputeWindowedPoSt(height int64, rawParams []byte) (map[string]interface{}, error) { - switch height { - case 15: + switch { + case tools.V15.IsSupported(height): return parseGeneric[*miner15.DisputeWindowedPoStParams, *miner15.DisputeWindowedPoStParams](rawParams, nil, false) + case tools.V14.IsSupported(height): + return parseGeneric[*miner14.DisputeWindowedPoStParams, *miner14.DisputeWindowedPoStParams](rawParams, nil, false) + case tools.V13.IsSupported(height): + return parseGeneric[*miner13.DisputeWindowedPoStParams, *miner13.DisputeWindowedPoStParams](rawParams, nil, false) + case tools.V12.IsSupported(height): + return parseGeneric[*miner12.DisputeWindowedPoStParams, *miner12.DisputeWindowedPoStParams](rawParams, nil, false) + case tools.V11.IsSupported(height): + return parseGeneric[*miner11.DisputeWindowedPoStParams, *miner11.DisputeWindowedPoStParams](rawParams, nil, false) + case tools.V10.IsSupported(height): + return parseGeneric[*miner10.DisputeWindowedPoStParams, *miner10.DisputeWindowedPoStParams](rawParams, nil, false) + case tools.V9.IsSupported(height): + return parseGeneric[*miner9.DisputeWindowedPoStParams, *miner9.DisputeWindowedPoStParams](rawParams, nil, false) + case tools.V8.IsSupported(height): + return parseGeneric[*miner8.DisputeWindowedPoStParams, *miner8.DisputeWindowedPoStParams](rawParams, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) } func ReportConsensusFault(height int64, rawParams []byte) (map[string]interface{}, error) { - switch height { - case 15: + switch { + case tools.V15.IsSupported(height): return parseGeneric[*miner15.ReportConsensusFaultParams, *miner15.ReportConsensusFaultParams](rawParams, nil, false) + case tools.V14.IsSupported(height): + return parseGeneric[*miner14.ReportConsensusFaultParams, *miner14.ReportConsensusFaultParams](rawParams, nil, false) + case tools.V13.IsSupported(height): + return parseGeneric[*miner13.ReportConsensusFaultParams, *miner13.ReportConsensusFaultParams](rawParams, nil, false) + case tools.V12.IsSupported(height): + return parseGeneric[*miner12.ReportConsensusFaultParams, *miner12.ReportConsensusFaultParams](rawParams, nil, false) + case tools.V11.IsSupported(height): + return parseGeneric[*miner11.ReportConsensusFaultParams, *miner11.ReportConsensusFaultParams](rawParams, nil, false) + case tools.V10.IsSupported(height): + return parseGeneric[*miner10.ReportConsensusFaultParams, *miner10.ReportConsensusFaultParams](rawParams, nil, false) + case tools.V9.IsSupported(height): + return parseGeneric[*miner9.ReportConsensusFaultParams, *miner9.ReportConsensusFaultParams](rawParams, nil, false) + case tools.V8.IsSupported(height): + return parseGeneric[*miner8.ReportConsensusFaultParams, *miner8.ReportConsensusFaultParams](rawParams, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) } func ChangeBeneficiary(height int64, rawParams []byte) (map[string]interface{}, error) { - switch height { - case 15: + switch { + case tools.V15.IsSupported(height): return parseGeneric[*miner15.ChangeBeneficiaryParams, *miner15.ChangeBeneficiaryParams](rawParams, nil, false) + case tools.V14.IsSupported(height): + return parseGeneric[*miner14.ChangeBeneficiaryParams, *miner14.ChangeBeneficiaryParams](rawParams, nil, false) + case tools.V13.IsSupported(height): + return parseGeneric[*miner13.ChangeBeneficiaryParams, *miner13.ChangeBeneficiaryParams](rawParams, nil, false) + case tools.V12.IsSupported(height): + return parseGeneric[*miner12.ChangeBeneficiaryParams, *miner12.ChangeBeneficiaryParams](rawParams, nil, false) + case tools.V11.IsSupported(height): + return parseGeneric[*miner11.ChangeBeneficiaryParams, *miner11.ChangeBeneficiaryParams](rawParams, nil, false) + case tools.V10.IsSupported(height): + return parseGeneric[*miner10.ChangeBeneficiaryParams, *miner10.ChangeBeneficiaryParams](rawParams, nil, false) + case tools.V9.IsSupported(height): + return parseGeneric[*miner9.ChangeBeneficiaryParams, *miner9.ChangeBeneficiaryParams](rawParams, nil, false) + case tools.V8.IsSupported(height): + return parseGeneric[*miner8.ChangeBeneficiaryParams, *miner8.ChangeBeneficiaryParams](rawParams, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) } func MinerConstructor(height int64, rawParams []byte) (map[string]interface{}, error) { - switch height { - case 15: + switch { + case tools.V15.IsSupported(height): return parseGeneric[*miner15.MinerConstructorParams, *miner15.MinerConstructorParams](rawParams, nil, false) + case tools.V14.IsSupported(height): + return parseGeneric[*miner14.MinerConstructorParams, *miner14.MinerConstructorParams](rawParams, nil, false) + case tools.V13.IsSupported(height): + return parseGeneric[*miner13.MinerConstructorParams, *miner13.MinerConstructorParams](rawParams, nil, false) + case tools.V12.IsSupported(height): + return parseGeneric[*miner12.MinerConstructorParams, *miner12.MinerConstructorParams](rawParams, nil, false) + case tools.V11.IsSupported(height): + return parseGeneric[*miner11.MinerConstructorParams, *miner11.MinerConstructorParams](rawParams, nil, false) + case tools.V10.IsSupported(height): + return parseGeneric[*miner10.MinerConstructorParams, *miner10.MinerConstructorParams](rawParams, nil, false) + case tools.V9.IsSupported(height): + return parseGeneric[*miner9.MinerConstructorParams, *miner9.MinerConstructorParams](rawParams, nil, false) + case tools.V8.IsSupported(height): + return parseGeneric[*miner8.MinerConstructorParams, *miner8.MinerConstructorParams](rawParams, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) } func ApplyRewards(height int64, rawParams []byte) (map[string]interface{}, error) { - switch height { - case 15: + switch { + case tools.V15.IsSupported(height): return parseGeneric[*miner15.ApplyRewardParams, *miner15.ApplyRewardParams](rawParams, nil, false) + case tools.V14.IsSupported(height): + return parseGeneric[*miner14.ApplyRewardParams, *miner14.ApplyRewardParams](rawParams, nil, false) + case tools.V13.IsSupported(height): + return parseGeneric[*miner13.ApplyRewardParams, *miner13.ApplyRewardParams](rawParams, nil, false) + case tools.V12.IsSupported(height): + return parseGeneric[*miner12.ApplyRewardParams, *miner12.ApplyRewardParams](rawParams, nil, false) + case tools.V11.IsSupported(height): + return parseGeneric[*miner11.ApplyRewardParams, *miner11.ApplyRewardParams](rawParams, nil, false) + case tools.V10.IsSupported(height): + return parseGeneric[*miner10.ApplyRewardParams, *miner10.ApplyRewardParams](rawParams, nil, false) + case tools.V9.IsSupported(height): + return parseGeneric[*miner9.ApplyRewardParams, *miner9.ApplyRewardParams](rawParams, nil, false) + case tools.V8.IsSupported(height): + return parseGeneric[*miner8.ApplyRewardParams, *miner8.ApplyRewardParams](rawParams, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) } func OnDeferredCronEvent(height int64, rawParams []byte) (map[string]interface{}, error) { - switch height { - case 15: + switch { + case tools.V15.IsSupported(height): return parseGeneric[*miner15.DeferredCronEventParams, *miner15.DeferredCronEventParams](rawParams, nil, false) + case tools.V14.IsSupported(height): + return parseGeneric[*miner14.DeferredCronEventParams, *miner14.DeferredCronEventParams](rawParams, nil, false) + case tools.V13.IsSupported(height): + return parseGeneric[*miner13.DeferredCronEventParams, *miner13.DeferredCronEventParams](rawParams, nil, false) + case tools.V12.IsSupported(height): + return parseGeneric[*miner12.DeferredCronEventParams, *miner12.DeferredCronEventParams](rawParams, nil, false) + case tools.V11.IsSupported(height): + return parseGeneric[*miner11.DeferredCronEventParams, *miner11.DeferredCronEventParams](rawParams, nil, false) + case tools.V10.IsSupported(height): + return parseGeneric[*miner10.DeferredCronEventParams, *miner10.DeferredCronEventParams](rawParams, nil, false) + case tools.V9.IsSupported(height): + return parseGeneric[*miner9.DeferredCronEventParams, *miner9.DeferredCronEventParams](rawParams, nil, false) + case tools.V8.IsSupported(height): + return parseGeneric[*miner8.DeferredCronEventParams, *miner8.DeferredCronEventParams](rawParams, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) } diff --git a/actors/miner/sector.go b/actors/miner/sector.go index dce89d52..17490e42 100644 --- a/actors/miner/sector.go +++ b/actors/miner/sector.go @@ -3,101 +3,277 @@ package miner import ( "fmt" + miner10 "github.com/filecoin-project/go-state-types/builtin/v10/miner" + miner11 "github.com/filecoin-project/go-state-types/builtin/v11/miner" + miner12 "github.com/filecoin-project/go-state-types/builtin/v12/miner" + miner13 "github.com/filecoin-project/go-state-types/builtin/v13/miner" + miner14 "github.com/filecoin-project/go-state-types/builtin/v14/miner" miner15 "github.com/filecoin-project/go-state-types/builtin/v15/miner" + miner8 "github.com/filecoin-project/go-state-types/builtin/v8/miner" + miner9 "github.com/filecoin-project/go-state-types/builtin/v9/miner" + "github.com/filecoin-project/lotus/chain/actors/builtin/tools" ) func ExtendSectorExpiration2(height int64, rawParams []byte) (map[string]interface{}, error) { - switch height { - case 15: + switch { + case tools.V15.IsSupported(height): return parseGeneric[*miner15.ExtendSectorExpiration2Params, *miner15.ExtendSectorExpiration2Params](rawParams, nil, false) + case tools.V14.IsSupported(height): + return parseGeneric[*miner14.ExtendSectorExpiration2Params, *miner14.ExtendSectorExpiration2Params](rawParams, nil, false) + case tools.V13.IsSupported(height): + return parseGeneric[*miner13.ExtendSectorExpiration2Params, *miner13.ExtendSectorExpiration2Params](rawParams, nil, false) + case tools.V12.IsSupported(height): + return parseGeneric[*miner12.ExtendSectorExpiration2Params, *miner12.ExtendSectorExpiration2Params](rawParams, nil, false) + case tools.V11.IsSupported(height): + return parseGeneric[*miner11.ExtendSectorExpiration2Params, *miner11.ExtendSectorExpiration2Params](rawParams, nil, false) + case tools.V10.IsSupported(height): + return parseGeneric[*miner10.ExtendSectorExpiration2Params, *miner10.ExtendSectorExpiration2Params](rawParams, nil, false) + case tools.V9.IsSupported(height): + return parseGeneric[*miner9.ExtendSectorExpiration2Params, *miner9.ExtendSectorExpiration2Params](rawParams, nil, false) + case tools.V8.IsSupported(height): + return parseGeneric[*miner8.ExtendSectorExpiration2Params, *miner8.ExtendSectorExpiration2Params](rawParams, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) } func PreCommitSector(height int64, rawParams []byte) (map[string]interface{}, error) { - switch height { - case 15: + switch { + case tools.V15.IsSupported(height): return parseGeneric[*miner15.PreCommitSectorParams, *miner15.PreCommitSectorParams](rawParams, nil, false) + case tools.V14.IsSupported(height): + return parseGeneric[*miner14.PreCommitSectorParams, *miner14.PreCommitSectorParams](rawParams, nil, false) + case tools.V13.IsSupported(height): + return parseGeneric[*miner13.PreCommitSectorParams, *miner13.PreCommitSectorParams](rawParams, nil, false) + case tools.V12.IsSupported(height): + return parseGeneric[*miner12.PreCommitSectorParams, *miner12.PreCommitSectorParams](rawParams, nil, false) + case tools.V11.IsSupported(height): + return parseGeneric[*miner11.PreCommitSectorParams, *miner11.PreCommitSectorParams](rawParams, nil, false) + case tools.V10.IsSupported(height): + return parseGeneric[*miner10.PreCommitSectorParams, *miner10.PreCommitSectorParams](rawParams, nil, false) + case tools.V9.IsSupported(height): + return parseGeneric[*miner9.PreCommitSectorParams, *miner9.PreCommitSectorParams](rawParams, nil, false) + case tools.V8.IsSupported(height): + return parseGeneric[*miner8.PreCommitSectorParams, *miner8.PreCommitSectorParams](rawParams, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) } func ProveCommitSector(height int64, rawParams []byte) (map[string]interface{}, error) { - switch height { - case 15: + switch { + case tools.V15.IsSupported(height): return parseGeneric[*miner15.ProveCommitSectorParams, *miner15.ProveCommitSectorParams](rawParams, nil, false) + case tools.V14.IsSupported(height): + return parseGeneric[*miner14.ProveCommitSectorParams, *miner14.ProveCommitSectorParams](rawParams, nil, false) + case tools.V13.IsSupported(height): + return parseGeneric[*miner13.ProveCommitSectorParams, *miner13.ProveCommitSectorParams](rawParams, nil, false) + case tools.V12.IsSupported(height): + return parseGeneric[*miner12.ProveCommitSectorParams, *miner12.ProveCommitSectorParams](rawParams, nil, false) + case tools.V11.IsSupported(height): + return parseGeneric[*miner11.ProveCommitSectorParams, *miner11.ProveCommitSectorParams](rawParams, nil, false) + case tools.V10.IsSupported(height): + return parseGeneric[*miner10.ProveCommitSectorParams, *miner10.ProveCommitSectorParams](rawParams, nil, false) + case tools.V9.IsSupported(height): + return parseGeneric[*miner9.ProveCommitSectorParams, *miner9.ProveCommitSectorParams](rawParams, nil, false) + case tools.V8.IsSupported(height): + return parseGeneric[*miner8.ProveCommitSectorParams, *miner8.ProveCommitSectorParams](rawParams, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) } func ProveCommitSectors3(height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { - switch height { - case 15: + switch { + case tools.V15.IsSupported(height): return parseGeneric[*miner15.ProveCommitSectors3Params, *miner15.ProveCommitSectors3Return](rawParams, rawReturn, true) + case tools.V14.IsSupported(height): + return parseGeneric[*miner14.ProveCommitSectors3Params, *miner14.ProveCommitSectors3Return](rawParams, rawReturn, true) + case tools.V13.IsSupported(height): + return parseGeneric[*miner13.ProveCommitSectors3Params, *miner13.ProveCommitSectors3Return](rawParams, rawReturn, true) + case tools.V12.IsSupported(height): + return parseGeneric[*miner12.ProveCommitSectors3Params, *miner12.ProveCommitSectors3Return](rawParams, rawReturn, true) + case tools.V11.IsSupported(height): + return parseGeneric[*miner11.ProveCommitSectors3Params, *miner11.ProveCommitSectors3Return](rawParams, rawReturn, true) + case tools.V10.IsSupported(height): + return parseGeneric[*miner10.ProveCommitSectors3Params, *miner10.ProveCommitSectors3Return](rawParams, rawReturn, true) + case tools.V9.IsSupported(height): + return parseGeneric[*miner9.ProveCommitSectors3Params, *miner9.ProveCommitSectors3Return](rawParams, rawReturn, true) + case tools.V8.IsSupported(height): + return parseGeneric[*miner8.ProveCommitSectors3Params, *miner8.ProveCommitSectors3Return](rawParams, rawReturn, true) } return nil, fmt.Errorf("unsupported height: %d", height) } func SubmitWindowedPoSt(height int64, rawParams []byte) (map[string]interface{}, error) { - switch height { - case 15: + switch { + case tools.V15.IsSupported(height): return parseGeneric[*miner15.SubmitWindowedPoStParams, *miner15.SubmitWindowedPoStParams](rawParams, nil, false) + case tools.V14.IsSupported(height): + return parseGeneric[*miner14.SubmitWindowedPoStParams, *miner14.SubmitWindowedPoStParams](rawParams, nil, false) + case tools.V13.IsSupported(height): + return parseGeneric[*miner13.SubmitWindowedPoStParams, *miner13.SubmitWindowedPoStParams](rawParams, nil, false) + case tools.V12.IsSupported(height): + return parseGeneric[*miner12.SubmitWindowedPoStParams, *miner12.SubmitWindowedPoStParams](rawParams, nil, false) + case tools.V11.IsSupported(height): + return parseGeneric[*miner11.SubmitWindowedPoStParams, *miner11.SubmitWindowedPoStParams](rawParams, nil, false) + case tools.V10.IsSupported(height): + return parseGeneric[*miner10.SubmitWindowedPoStParams, *miner10.SubmitWindowedPoStParams](rawParams, nil, false) + case tools.V9.IsSupported(height): + return parseGeneric[*miner9.SubmitWindowedPoStParams, *miner9.SubmitWindowedPoStParams](rawParams, nil, false) + case tools.V8.IsSupported(height): + return parseGeneric[*miner8.SubmitWindowedPoStParams, *miner8.SubmitWindowedPoStParams](rawParams, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) } func ConfirmSectorProofsValid(height int64, rawParams []byte) (map[string]interface{}, error) { - switch height { - case 15: + switch { + case tools.V15.IsSupported(height): return parseGeneric[*miner15.ConfirmSectorProofsParams, *miner15.ConfirmSectorProofsParams](rawParams, nil, false) + case tools.V14.IsSupported(height): + return parseGeneric[*miner14.ConfirmSectorProofsParams, *miner14.ConfirmSectorProofsParams](rawParams, nil, false) + case tools.V13.IsSupported(height): + return parseGeneric[*miner13.ConfirmSectorProofsParams, *miner13.ConfirmSectorProofsParams](rawParams, nil, false) + case tools.V12.IsSupported(height): + return parseGeneric[*miner12.ConfirmSectorProofsParams, *miner12.ConfirmSectorProofsParams](rawParams, nil, false) + case tools.V11.IsSupported(height): + return parseGeneric[*miner11.ConfirmSectorProofsParams, *miner11.ConfirmSectorProofsParams](rawParams, nil, false) + case tools.V10.IsSupported(height): + return parseGeneric[*miner10.ConfirmSectorProofsParams, *miner10.ConfirmSectorProofsParams](rawParams, nil, false) + case tools.V9.IsSupported(height): + return parseGeneric[*miner9.ConfirmSectorProofsParams, *miner9.ConfirmSectorProofsParams](rawParams, nil, false) + case tools.V8.IsSupported(height): + return parseGeneric[*miner8.ConfirmSectorProofsParams, *miner8.ConfirmSectorProofsParams](rawParams, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) } func CheckSectorProven(height int64, rawParams []byte) (map[string]interface{}, error) { - switch height { - case 15: + switch { + case tools.V15.IsSupported(height): return parseGeneric[*miner15.CheckSectorProvenParams, *miner15.CheckSectorProvenParams](rawParams, nil, false) + case tools.V14.IsSupported(height): + return parseGeneric[*miner14.CheckSectorProvenParams, *miner14.CheckSectorProvenParams](rawParams, nil, false) + case tools.V13.IsSupported(height): + return parseGeneric[*miner13.CheckSectorProvenParams, *miner13.CheckSectorProvenParams](rawParams, nil, false) + case tools.V12.IsSupported(height): + return parseGeneric[*miner12.CheckSectorProvenParams, *miner12.CheckSectorProvenParams](rawParams, nil, false) + case tools.V11.IsSupported(height): + return parseGeneric[*miner11.CheckSectorProvenParams, *miner11.CheckSectorProvenParams](rawParams, nil, false) + case tools.V10.IsSupported(height): + return parseGeneric[*miner10.CheckSectorProvenParams, *miner10.CheckSectorProvenParams](rawParams, nil, false) + case tools.V9.IsSupported(height): + return parseGeneric[*miner9.CheckSectorProvenParams, *miner9.CheckSectorProvenParams](rawParams, nil, false) + case tools.V8.IsSupported(height): + return parseGeneric[*miner8.CheckSectorProvenParams, *miner8.CheckSectorProvenParams](rawParams, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) } func ExtendSectorExpiration(height int64, rawParams []byte) (map[string]interface{}, error) { - switch height { - case 15: + switch { + case tools.V15.IsSupported(height): return parseGeneric[*miner15.ExtendSectorExpirationParams, *miner15.ExtendSectorExpirationParams](rawParams, nil, false) + case tools.V14.IsSupported(height): + return parseGeneric[*miner14.ExtendSectorExpirationParams, *miner14.ExtendSectorExpirationParams](rawParams, nil, false) + case tools.V13.IsSupported(height): + return parseGeneric[*miner13.ExtendSectorExpirationParams, *miner13.ExtendSectorExpirationParams](rawParams, nil, false) + case tools.V12.IsSupported(height): + return parseGeneric[*miner12.ExtendSectorExpirationParams, *miner12.ExtendSectorExpirationParams](rawParams, nil, false) + case tools.V11.IsSupported(height): + return parseGeneric[*miner11.ExtendSectorExpirationParams, *miner11.ExtendSectorExpirationParams](rawParams, nil, false) + case tools.V10.IsSupported(height): + return parseGeneric[*miner10.ExtendSectorExpirationParams, *miner10.ExtendSectorExpirationParams](rawParams, nil, false) + case tools.V9.IsSupported(height): + return parseGeneric[*miner9.ExtendSectorExpirationParams, *miner9.ExtendSectorExpirationParams](rawParams, nil, false) + case tools.V8.IsSupported(height): + return parseGeneric[*miner8.ExtendSectorExpirationParams, *miner8.ExtendSectorExpirationParams](rawParams, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) } func CompactSectorNumbers(height int64, rawParams []byte) (map[string]interface{}, error) { - switch height { - case 15: + switch { + case tools.V15.IsSupported(height): return parseGeneric[*miner15.CompactSectorNumbersParams, *miner15.CompactSectorNumbersParams](rawParams, nil, false) + case tools.V14.IsSupported(height): + return parseGeneric[*miner14.CompactSectorNumbersParams, *miner14.CompactSectorNumbersParams](rawParams, nil, false) + case tools.V13.IsSupported(height): + return parseGeneric[*miner13.CompactSectorNumbersParams, *miner13.CompactSectorNumbersParams](rawParams, nil, false) + case tools.V12.IsSupported(height): + return parseGeneric[*miner12.CompactSectorNumbersParams, *miner12.CompactSectorNumbersParams](rawParams, nil, false) + case tools.V11.IsSupported(height): + return parseGeneric[*miner11.CompactSectorNumbersParams, *miner11.CompactSectorNumbersParams](rawParams, nil, false) + case tools.V10.IsSupported(height): + return parseGeneric[*miner10.CompactSectorNumbersParams, *miner10.CompactSectorNumbersParams](rawParams, nil, false) + case tools.V9.IsSupported(height): + return parseGeneric[*miner9.CompactSectorNumbersParams, *miner9.CompactSectorNumbersParams](rawParams, nil, false) + case tools.V8.IsSupported(height): + return parseGeneric[*miner8.CompactSectorNumbersParams, *miner8.CompactSectorNumbersParams](rawParams, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) } func CompactPartitions(height int64, rawParams []byte) (map[string]interface{}, error) { - switch height { - case 15: + switch { + case tools.V15.IsSupported(height): return parseGeneric[*miner15.CompactPartitionsParams, *miner15.CompactPartitionsParams](rawParams, nil, false) + case tools.V14.IsSupported(height): + return parseGeneric[*miner14.CompactPartitionsParams, *miner14.CompactPartitionsParams](rawParams, nil, false) + case tools.V13.IsSupported(height): + return parseGeneric[*miner13.CompactPartitionsParams, *miner13.CompactPartitionsParams](rawParams, nil, false) + case tools.V12.IsSupported(height): + return parseGeneric[*miner12.CompactPartitionsParams, *miner12.CompactPartitionsParams](rawParams, nil, false) + case tools.V11.IsSupported(height): + return parseGeneric[*miner11.CompactPartitionsParams, *miner11.CompactPartitionsParams](rawParams, nil, false) + case tools.V10.IsSupported(height): + return parseGeneric[*miner10.CompactPartitionsParams, *miner10.CompactPartitionsParams](rawParams, nil, false) + case tools.V9.IsSupported(height): + return parseGeneric[*miner9.CompactPartitionsParams, *miner9.CompactPartitionsParams](rawParams, nil, false) + case tools.V8.IsSupported(height): + return parseGeneric[*miner8.CompactPartitionsParams, *miner8.CompactPartitionsParams](rawParams, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) } func PreCommitSectorBatch(height int64, rawParams []byte) (map[string]interface{}, error) { - switch height { - case 15: + switch { + case tools.V15.IsSupported(height): return parseGeneric[*miner15.PreCommitSectorBatchParams, *miner15.PreCommitSectorBatchParams](rawParams, nil, false) + case tools.V14.IsSupported(height): + return parseGeneric[*miner14.PreCommitSectorBatchParams, *miner14.PreCommitSectorBatchParams](rawParams, nil, false) + case tools.V13.IsSupported(height): + return parseGeneric[*miner13.PreCommitSectorBatchParams, *miner13.PreCommitSectorBatchParams](rawParams, nil, false) + case tools.V12.IsSupported(height): + return parseGeneric[*miner12.PreCommitSectorBatchParams, *miner12.PreCommitSectorBatchParams](rawParams, nil, false) + case tools.V11.IsSupported(height): + return parseGeneric[*miner11.PreCommitSectorBatchParams, *miner11.PreCommitSectorBatchParams](rawParams, nil, false) + case tools.V10.IsSupported(height): + return parseGeneric[*miner10.PreCommitSectorBatchParams, *miner10.PreCommitSectorBatchParams](rawParams, nil, false) + case tools.V9.IsSupported(height): + return parseGeneric[*miner9.PreCommitSectorBatchParams, *miner9.PreCommitSectorBatchParams](rawParams, nil, false) + case tools.V8.IsSupported(height): + return parseGeneric[*miner8.PreCommitSectorBatchParams, *miner8.PreCommitSectorBatchParams](rawParams, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) } func GetSectorSize(height int64, rawReturn []byte) (map[string]interface{}, error) { - switch height { - case 15: + switch { + case tools.V15.IsSupported(height): return parseGeneric[*miner15.GetSectorSizeReturn, *miner15.GetSectorSizeReturn](rawReturn, nil, false) + case tools.V14.IsSupported(height): + return parseGeneric[*miner14.GetSectorSizeReturn, *miner14.GetSectorSizeReturn](rawReturn, nil, false) + case tools.V13.IsSupported(height): + return parseGeneric[*miner13.GetSectorSizeReturn, *miner13.GetSectorSizeReturn](rawReturn, nil, false) + case tools.V12.IsSupported(height): + return parseGeneric[*miner12.GetSectorSizeReturn, *miner12.GetSectorSizeReturn](rawReturn, nil, false) + case tools.V11.IsSupported(height): + return parseGeneric[*miner11.GetSectorSizeReturn, *miner11.GetSectorSizeReturn](rawReturn, nil, false) + case tools.V10.IsSupported(height): + return parseGeneric[*miner10.GetSectorSizeReturn, *miner10.GetSectorSizeReturn](rawReturn, nil, false) + case tools.V9.IsSupported(height): + return parseGeneric[*miner9.GetSectorSizeReturn, *miner9.GetSectorSizeReturn](rawReturn, nil, false) + case tools.V8.IsSupported(height): + return parseGeneric[*miner8.GetSectorSizeReturn, *miner8.GetSectorSizeReturn](rawReturn, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) } diff --git a/actors/multisig/generic.go b/actors/multisig/generic.go index c3a500b8..ed82a0cb 100644 --- a/actors/multisig/generic.go +++ b/actors/multisig/generic.go @@ -1,11 +1,59 @@ package multisig import ( + "bytes" "encoding/json" "fmt" "io" + + filTypes "github.com/filecoin-project/lotus/chain/types" + "github.com/zondax/fil-parser/parser" ) +func parseWithMsigParser[T multisigParams, R multisigReturn](msg *parser.LotusMessage, + height int64, + key filTypes.TipSetKey, + fn parseFn, + rawReturn []byte, + unmarshaller func(io.Reader, any) error, + customReturn bool, +) (map[string]interface{}, error) { + + metadata := make(map[string]interface{}) + params, err := fn(msg, height, key) + if err != nil { + return map[string]interface{}{}, err + } + metadata[parser.ParamsKey] = params + + if customReturn { + var r R + err = unmarshaller(bytes.NewReader(rawReturn), &r) + if err != nil { + return map[string]interface{}{}, err + } + metadata[parser.ReturnKey] = r + } + return metadata, nil + +} + +func parse[T multisigParams, P []byte | string](raw P, unmarshaller func(io.Reader, any) error) (map[string]interface{}, error) { + metadata := make(map[string]interface{}) + var params T + rawBytes, err := toBytes(raw) + if err != nil { + return map[string]interface{}{}, err + } + reader := bytes.NewReader(rawBytes) + err = unmarshaller(reader, ¶ms) + if err != nil { + return map[string]interface{}{}, err + } + metadata[parser.ParamsKey] = params + return metadata, nil +} + func getValue[T multisigParams](height int64, raw map[string]interface{}) (interface{}, error) { paramsRaw, ok := raw["Params"].(map[string]interface{}) if !ok { diff --git a/actors/multisig/multisig.go b/actors/multisig/multisig.go index 8bb37f2e..46f1513a 100644 --- a/actors/multisig/multisig.go +++ b/actors/multisig/multisig.go @@ -1,9 +1,6 @@ package multisig import ( - "bytes" - "io" - filTypes "github.com/filecoin-project/lotus/chain/types" "github.com/filecoin-project/go-state-types/abi" @@ -17,125 +14,180 @@ import ( multisig9 "github.com/filecoin-project/go-state-types/builtin/v9/multisig" "github.com/zondax/fil-parser/parser" + "github.com/zondax/fil-parser/tools" ) -func parseWithMsigParser[T multisigParams, R multisigReturn](msg *parser.LotusMessage, - height int64, - key filTypes.TipSetKey, - fn parseFn, - rawReturn []byte, - unmarshaller func(io.Reader, any) error, - customReturn bool, -) (map[string]interface{}, error) { - - metadata := make(map[string]interface{}) - params, err := fn(msg, height, key) - if err != nil { - return map[string]interface{}{}, err - } - metadata[parser.ParamsKey] = params - - if customReturn { - var r R - err = unmarshaller(bytes.NewReader(rawReturn), &r) - if err != nil { - return map[string]interface{}{}, err - } - metadata[parser.ReturnKey] = r - } - return metadata, nil - -} - -func parse[T multisigParams, P []byte | string](raw P, unmarshaller func(io.Reader, any) error) (map[string]interface{}, error) { - metadata := make(map[string]interface{}) - var params T - rawBytes, err := toBytes(raw) - if err != nil { - return map[string]interface{}{}, err - } - reader := bytes.NewReader(rawBytes) - err = unmarshaller(reader, ¶ms) - if err != nil { - return map[string]interface{}{}, err - } - metadata[parser.ParamsKey] = params - return metadata, nil -} - func MsigConstructor(height int64, raw []byte) (map[string]interface{}, error) { - switch height { - case 8: + switch { + case tools.V8.IsSupported(height): return parse[*multisig8.ConstructorParams, []byte](raw, cborUnmarshaller[*multisig8.ConstructorParams]) - case 9: + case tools.V9.IsSupported(height): return parse[*multisig9.ConstructorParams, []byte](raw, cborUnmarshaller[*multisig9.ConstructorParams]) - case 10: + case tools.V10.IsSupported(height): return parse[*multisig10.ConstructorParams, []byte](raw, cborUnmarshaller[*multisig10.ConstructorParams]) - case 11: + case tools.V11.IsSupported(height): return parse[*multisig11.ConstructorParams, []byte](raw, cborUnmarshaller[*multisig11.ConstructorParams]) - case 12: + case tools.V12.IsSupported(height): return parse[*multisig12.ConstructorParams, []byte](raw, cborUnmarshaller[*multisig12.ConstructorParams]) - case 13: + case tools.V13.IsSupported(height): return parse[*multisig13.ConstructorParams, []byte](raw, cborUnmarshaller[*multisig13.ConstructorParams]) - case 14: + case tools.V14.IsSupported(height): return parse[*multisig14.ConstructorParams, []byte](raw, cborUnmarshaller[*multisig14.ConstructorParams]) - case 15: + case tools.V15.IsSupported(height): return parse[*multisig15.ConstructorParams, []byte](raw, cborUnmarshaller[*multisig15.ConstructorParams]) } return map[string]interface{}{}, nil } func MsigParams(msg *parser.LotusMessage, height int64, key filTypes.TipSetKey, parser parseFn) (map[string]interface{}, error) { - switch height { - case 8: + switch { + case tools.V8.IsSupported(height): return parseWithMsigParser[*multisig8.ConstructorParams, *multisig8.ConstructorParams](msg, height, key, parser, nil, jsonUnmarshaller[*multisig8.ConstructorParams], false) + case tools.V9.IsSupported(height): + return parseWithMsigParser[*multisig9.ConstructorParams, *multisig9.ConstructorParams](msg, height, key, parser, nil, jsonUnmarshaller[*multisig9.ConstructorParams], false) + case tools.V10.IsSupported(height): + return parseWithMsigParser[*multisig10.ConstructorParams, *multisig10.ConstructorParams](msg, height, key, parser, nil, jsonUnmarshaller[*multisig10.ConstructorParams], false) + case tools.V11.IsSupported(height): + return parseWithMsigParser[*multisig11.ConstructorParams, *multisig11.ConstructorParams](msg, height, key, parser, nil, jsonUnmarshaller[*multisig11.ConstructorParams], false) + case tools.V12.IsSupported(height): + return parseWithMsigParser[*multisig12.ConstructorParams, *multisig12.ConstructorParams](msg, height, key, parser, nil, jsonUnmarshaller[*multisig12.ConstructorParams], false) + case tools.V13.IsSupported(height): + return parseWithMsigParser[*multisig13.ConstructorParams, *multisig13.ConstructorParams](msg, height, key, parser, nil, jsonUnmarshaller[*multisig13.ConstructorParams], false) + case tools.V14.IsSupported(height): + return parseWithMsigParser[*multisig14.ConstructorParams, *multisig14.ConstructorParams](msg, height, key, parser, nil, jsonUnmarshaller[*multisig14.ConstructorParams], false) + case tools.V15.IsSupported(height): + return parseWithMsigParser[*multisig15.ConstructorParams, *multisig15.ConstructorParams](msg, height, key, parser, nil, jsonUnmarshaller[*multisig15.ConstructorParams], false) } return map[string]interface{}{}, nil } func Approve(msg *parser.LotusMessage, height int64, key filTypes.TipSetKey, rawReturn []byte, parser parseFn) (map[string]interface{}, error) { - switch height { - case 8: + switch { + case tools.V8.IsSupported(height): return parseWithMsigParser[*multisig8.ApproveReturn, *multisig8.ApproveReturn](msg, height, key, parser, rawReturn, cborUnmarshaller[*multisig8.ApproveReturn], true) + case tools.V9.IsSupported(height): + return parseWithMsigParser[*multisig9.ApproveReturn, *multisig9.ApproveReturn](msg, height, key, parser, rawReturn, cborUnmarshaller[*multisig9.ApproveReturn], true) + case tools.V10.IsSupported(height): + return parseWithMsigParser[*multisig10.ApproveReturn, *multisig10.ApproveReturn](msg, height, key, parser, rawReturn, cborUnmarshaller[*multisig10.ApproveReturn], true) + case tools.V11.IsSupported(height): + return parseWithMsigParser[*multisig11.ApproveReturn, *multisig11.ApproveReturn](msg, height, key, parser, rawReturn, cborUnmarshaller[*multisig11.ApproveReturn], true) + case tools.V12.IsSupported(height): + return parseWithMsigParser[*multisig12.ApproveReturn, *multisig12.ApproveReturn](msg, height, key, parser, rawReturn, cborUnmarshaller[*multisig12.ApproveReturn], true) + case tools.V13.IsSupported(height): + return parseWithMsigParser[*multisig13.ApproveReturn, *multisig13.ApproveReturn](msg, height, key, parser, rawReturn, cborUnmarshaller[*multisig13.ApproveReturn], true) + case tools.V14.IsSupported(height): + return parseWithMsigParser[*multisig14.ApproveReturn, *multisig14.ApproveReturn](msg, height, key, parser, rawReturn, cborUnmarshaller[*multisig14.ApproveReturn], true) + case tools.V15.IsSupported(height): + return parseWithMsigParser[*multisig15.ApproveReturn, *multisig15.ApproveReturn](msg, height, key, parser, rawReturn, cborUnmarshaller[*multisig15.ApproveReturn], true) } return map[string]interface{}{}, nil } func Cancel(msg *parser.LotusMessage, height int64, key filTypes.TipSetKey, rawReturn []byte, parser parseFn) (map[string]interface{}, error) { - switch height { - case 8: + switch { + case tools.V8.IsSupported(height): + return parseWithMsigParser[metadataWithCbor, metadataWithCbor](msg, height, key, parser, rawReturn, noopUnmarshaller[metadataWithCbor], false) + case tools.V9.IsSupported(height): + return parseWithMsigParser[metadataWithCbor, metadataWithCbor](msg, height, key, parser, rawReturn, noopUnmarshaller[metadataWithCbor], false) + case tools.V10.IsSupported(height): + return parseWithMsigParser[metadataWithCbor, metadataWithCbor](msg, height, key, parser, rawReturn, noopUnmarshaller[metadataWithCbor], false) + case tools.V11.IsSupported(height): + return parseWithMsigParser[metadataWithCbor, metadataWithCbor](msg, height, key, parser, rawReturn, noopUnmarshaller[metadataWithCbor], false) + case tools.V12.IsSupported(height): + return parseWithMsigParser[metadataWithCbor, metadataWithCbor](msg, height, key, parser, rawReturn, noopUnmarshaller[metadataWithCbor], false) + case tools.V13.IsSupported(height): + return parseWithMsigParser[metadataWithCbor, metadataWithCbor](msg, height, key, parser, rawReturn, noopUnmarshaller[metadataWithCbor], false) + case tools.V14.IsSupported(height): + return parseWithMsigParser[metadataWithCbor, metadataWithCbor](msg, height, key, parser, rawReturn, noopUnmarshaller[metadataWithCbor], false) + case tools.V15.IsSupported(height): return parseWithMsigParser[metadataWithCbor, metadataWithCbor](msg, height, key, parser, rawReturn, noopUnmarshaller[metadataWithCbor], false) } return map[string]interface{}{}, nil } func RemoveSigner(msg *parser.LotusMessage, height int64, key filTypes.TipSetKey, rawReturn []byte, parser parseFn) (map[string]interface{}, error) { - switch height { - case 8: + switch { + case tools.V8.IsSupported(height): + return parseWithMsigParser[metadataWithCbor, metadataWithCbor](msg, height, key, parser, rawReturn, noopUnmarshaller[metadataWithCbor], false) + case tools.V9.IsSupported(height): + return parseWithMsigParser[metadataWithCbor, metadataWithCbor](msg, height, key, parser, rawReturn, noopUnmarshaller[metadataWithCbor], false) + case tools.V10.IsSupported(height): + return parseWithMsigParser[metadataWithCbor, metadataWithCbor](msg, height, key, parser, rawReturn, noopUnmarshaller[metadataWithCbor], false) + case tools.V11.IsSupported(height): + return parseWithMsigParser[metadataWithCbor, metadataWithCbor](msg, height, key, parser, rawReturn, noopUnmarshaller[metadataWithCbor], false) + case tools.V12.IsSupported(height): + return parseWithMsigParser[metadataWithCbor, metadataWithCbor](msg, height, key, parser, rawReturn, noopUnmarshaller[metadataWithCbor], false) + case tools.V13.IsSupported(height): + return parseWithMsigParser[metadataWithCbor, metadataWithCbor](msg, height, key, parser, rawReturn, noopUnmarshaller[metadataWithCbor], false) + case tools.V14.IsSupported(height): + return parseWithMsigParser[metadataWithCbor, metadataWithCbor](msg, height, key, parser, rawReturn, noopUnmarshaller[metadataWithCbor], false) + case tools.V15.IsSupported(height): return parseWithMsigParser[metadataWithCbor, metadataWithCbor](msg, height, key, parser, rawReturn, noopUnmarshaller[metadataWithCbor], false) } return map[string]interface{}{}, nil } func ChangeNumApprovalsThreshold(msg *parser.LotusMessage, height int64, key filTypes.TipSetKey, rawReturn []byte, parser parseFn) (map[string]interface{}, error) { - switch height { - case 8: + switch { + case tools.V8.IsSupported(height): return parse[*multisig8.ChangeNumApprovalsThresholdParams, []byte](rawReturn, cborUnmarshaller[*multisig8.ChangeNumApprovalsThresholdParams]) + case tools.V9.IsSupported(height): + return parse[*multisig9.ChangeNumApprovalsThresholdParams, []byte](rawReturn, cborUnmarshaller[*multisig9.ChangeNumApprovalsThresholdParams]) + case tools.V10.IsSupported(height): + return parse[*multisig10.ChangeNumApprovalsThresholdParams, []byte](rawReturn, cborUnmarshaller[*multisig10.ChangeNumApprovalsThresholdParams]) + case tools.V11.IsSupported(height): + return parse[*multisig11.ChangeNumApprovalsThresholdParams, []byte](rawReturn, cborUnmarshaller[*multisig11.ChangeNumApprovalsThresholdParams]) + case tools.V12.IsSupported(height): + return parse[*multisig12.ChangeNumApprovalsThresholdParams, []byte](rawReturn, cborUnmarshaller[*multisig12.ChangeNumApprovalsThresholdParams]) + case tools.V13.IsSupported(height): + return parse[*multisig13.ChangeNumApprovalsThresholdParams, []byte](rawReturn, cborUnmarshaller[*multisig13.ChangeNumApprovalsThresholdParams]) + case tools.V14.IsSupported(height): + return parse[*multisig14.ChangeNumApprovalsThresholdParams, []byte](rawReturn, cborUnmarshaller[*multisig14.ChangeNumApprovalsThresholdParams]) + case tools.V15.IsSupported(height): + return parse[*multisig15.ChangeNumApprovalsThresholdParams, []byte](rawReturn, cborUnmarshaller[*multisig15.ChangeNumApprovalsThresholdParams]) } return map[string]interface{}{}, nil } func LockBalance(msg *parser.LotusMessage, height int64, key filTypes.TipSetKey, rawReturn []byte, parser parseFn) (map[string]interface{}, error) { - switch height { - case 8: + switch { + case tools.V8.IsSupported(height): return parse[*multisig8.LockBalanceParams, []byte](rawReturn, cborUnmarshaller[*multisig8.LockBalanceParams]) + case tools.V9.IsSupported(height): + return parse[*multisig9.LockBalanceParams, []byte](rawReturn, cborUnmarshaller[*multisig9.LockBalanceParams]) + case tools.V10.IsSupported(height): + return parse[*multisig10.LockBalanceParams, []byte](rawReturn, cborUnmarshaller[*multisig10.LockBalanceParams]) + case tools.V11.IsSupported(height): + return parse[*multisig11.LockBalanceParams, []byte](rawReturn, cborUnmarshaller[*multisig11.LockBalanceParams]) + case tools.V12.IsSupported(height): + return parse[*multisig12.LockBalanceParams, []byte](rawReturn, cborUnmarshaller[*multisig12.LockBalanceParams]) + case tools.V13.IsSupported(height): + return parse[*multisig13.LockBalanceParams, []byte](rawReturn, cborUnmarshaller[*multisig13.LockBalanceParams]) + case tools.V14.IsSupported(height): + return parse[*multisig14.LockBalanceParams, []byte](rawReturn, cborUnmarshaller[*multisig14.LockBalanceParams]) + case tools.V15.IsSupported(height): + return parse[*multisig15.LockBalanceParams, []byte](rawReturn, cborUnmarshaller[*multisig15.LockBalanceParams]) } return map[string]interface{}{}, nil } func UniversalReceiverHook(msg *parser.LotusMessage, height int64, key filTypes.TipSetKey, rawReturn []byte, parser parseFn) (map[string]interface{}, error) { - switch height { - case 8: + switch { + case tools.V8.IsSupported(height): + return parse[*abi.CborBytesTransparent, []byte](rawReturn, cborUnmarshaller[*abi.CborBytesTransparent]) + case tools.V9.IsSupported(height): + return parse[*abi.CborBytesTransparent, []byte](rawReturn, cborUnmarshaller[*abi.CborBytesTransparent]) + case tools.V10.IsSupported(height): + return parse[*abi.CborBytesTransparent, []byte](rawReturn, cborUnmarshaller[*abi.CborBytesTransparent]) + case tools.V11.IsSupported(height): + return parse[*abi.CborBytesTransparent, []byte](rawReturn, cborUnmarshaller[*abi.CborBytesTransparent]) + case tools.V12.IsSupported(height): + return parse[*abi.CborBytesTransparent, []byte](rawReturn, cborUnmarshaller[*abi.CborBytesTransparent]) + case tools.V13.IsSupported(height): + return parse[*abi.CborBytesTransparent, []byte](rawReturn, cborUnmarshaller[*abi.CborBytesTransparent]) + case tools.V14.IsSupported(height): + return parse[*abi.CborBytesTransparent, []byte](rawReturn, cborUnmarshaller[*abi.CborBytesTransparent]) + case tools.V15.IsSupported(height): return parse[*abi.CborBytesTransparent, []byte](rawReturn, cborUnmarshaller[*abi.CborBytesTransparent]) } return map[string]interface{}{}, nil diff --git a/actors/multisig/utils.go b/actors/multisig/utils.go index 3092d615..8d201986 100644 --- a/actors/multisig/utils.go +++ b/actors/multisig/utils.go @@ -3,6 +3,18 @@ package multisig import ( "encoding/json" "errors" + "fmt" + + multisig10 "github.com/filecoin-project/go-state-types/builtin/v10/multisig" + multisig11 "github.com/filecoin-project/go-state-types/builtin/v11/multisig" + multisig12 "github.com/filecoin-project/go-state-types/builtin/v12/multisig" + multisig13 "github.com/filecoin-project/go-state-types/builtin/v13/multisig" + multisig14 "github.com/filecoin-project/go-state-types/builtin/v14/multisig" + multisig15 "github.com/filecoin-project/go-state-types/builtin/v15/multisig" + multisig8 "github.com/filecoin-project/go-state-types/builtin/v8/multisig" + multisig9 "github.com/filecoin-project/go-state-types/builtin/v9/multisig" + "github.com/filecoin-project/go-state-types/exitcode" + "github.com/zondax/fil-parser/tools" ) func toBytes(raw any) ([]byte, error) { @@ -22,3 +34,152 @@ func mapToStruct(m map[string]interface{}, v interface{}) error { } return json.Unmarshal(data, v) } + +func getApproveReturn(height int64, raw map[string]interface{}) (interface{}, error) { + var params ApproveValue + + returnRaw, ok := raw["Return"].(map[string]interface{}) + if !ok { + return nil, fmt.Errorf("Return not found or not a map") + } + + applied, ok := returnRaw["Applied"].(bool) + if !ok { + return nil, fmt.Errorf("Applied not found or not a bool") + } + + code, ok := returnRaw["Code"].(float64) + if !ok { + return nil, fmt.Errorf("Code not found or not a float64") + } + + ret, ok := returnRaw["Ret"].(string) + if !ok { + return nil, fmt.Errorf("Ret not found or not a string") + } + + switch { + case tools.V8.IsSupported(height): + params.Return = multisig8.ApproveReturn{ + Applied: applied, + Code: exitcode.ExitCode(code), + Ret: []byte(ret), + } + case tools.V9.IsSupported(height): + params.Return = multisig9.ApproveReturn{ + Applied: applied, + Code: exitcode.ExitCode(code), + Ret: []byte(ret), + } + case tools.V10.IsSupported(height): + params.Return = multisig10.ApproveReturn{ + Applied: applied, + Code: exitcode.ExitCode(code), + Ret: []byte(ret), + } + case tools.V11.IsSupported(height): + params.Return = multisig11.ApproveReturn{ + Applied: applied, + Code: exitcode.ExitCode(code), + Ret: []byte(ret), + } + case tools.V12.IsSupported(height): + params.Return = multisig12.ApproveReturn{ + Applied: applied, + Code: exitcode.ExitCode(code), + Ret: []byte(ret), + } + case tools.V13.IsSupported(height): + params.Return = multisig13.ApproveReturn{ + Applied: applied, + Code: exitcode.ExitCode(code), + Ret: []byte(ret), + } + case tools.V14.IsSupported(height): + params.Return = multisig14.ApproveReturn{ + Applied: applied, + Code: exitcode.ExitCode(code), + Ret: []byte(ret), + } + case tools.V15.IsSupported(height): + params.Return = multisig15.ApproveReturn{ + Applied: applied, + Code: exitcode.ExitCode(code), + Ret: []byte(ret), + } + } + + return params, nil +} + +func getCancelReturn(height int64, raw map[string]interface{}) (interface{}, error) { + paramsStr, ok := raw["Params"].(string) + if !ok { + return nil, fmt.Errorf("Params not found or not a string") + } + + var paramsRaw map[string]interface{} + err := json.Unmarshal([]byte(paramsStr), ¶msRaw) + if err != nil { + return nil, err + } + + var v CancelValue + err = mapToStruct(paramsRaw, &v) + if err != nil { + return nil, err + } + + return v, nil +} + +func getChangeNumApprovalsThresholdValue(height int64, raw map[string]interface{}) (interface{}, error) { + paramsStr, ok := raw["Params"].(map[string]interface{}) + if !ok { + return nil, fmt.Errorf("Params not found or not a map") + } + + var newValue uint64 + if newThreshold, ok := paramsStr["NewThreshold"].(float64); ok { + newValue = uint64(newThreshold) + } else { + return nil, fmt.Errorf("NewThreshold not found or not a number") + } + var v any + switch { + case tools.V8.IsSupported(height): + v = multisig8.ChangeNumApprovalsThresholdParams{ + NewThreshold: newValue, + } + case tools.V9.IsSupported(height): + v = multisig9.ChangeNumApprovalsThresholdParams{ + NewThreshold: newValue, + } + case tools.V10.IsSupported(height): + v = multisig10.ChangeNumApprovalsThresholdParams{ + NewThreshold: newValue, + } + case tools.V11.IsSupported(height): + v = multisig11.ChangeNumApprovalsThresholdParams{ + NewThreshold: newValue, + } + case tools.V12.IsSupported(height): + v = multisig12.ChangeNumApprovalsThresholdParams{ + NewThreshold: newValue, + } + case tools.V13.IsSupported(height): + v = multisig13.ChangeNumApprovalsThresholdParams{ + NewThreshold: newValue, + } + case tools.V14.IsSupported(height): + v = multisig14.ChangeNumApprovalsThresholdParams{ + NewThreshold: newValue, + } + case tools.V15.IsSupported(height): + v = multisig15.ChangeNumApprovalsThresholdParams{ + NewThreshold: newValue, + } + } + + return v, nil +} diff --git a/actors/multisig/values.go b/actors/multisig/values.go index cfdf9547..3f88e5b2 100644 --- a/actors/multisig/values.go +++ b/actors/multisig/values.go @@ -2,48 +2,152 @@ package multisig import ( "encoding/json" - "fmt" + multisig10 "github.com/filecoin-project/go-state-types/builtin/v10/multisig" miner11 "github.com/filecoin-project/go-state-types/builtin/v11/miner" multisig11 "github.com/filecoin-project/go-state-types/builtin/v11/multisig" - "github.com/filecoin-project/go-state-types/exitcode" + multisig12 "github.com/filecoin-project/go-state-types/builtin/v12/multisig" + multisig13 "github.com/filecoin-project/go-state-types/builtin/v13/multisig" + multisig14 "github.com/filecoin-project/go-state-types/builtin/v14/multisig" + multisig15 "github.com/filecoin-project/go-state-types/builtin/v15/multisig" + multisig8 "github.com/filecoin-project/go-state-types/builtin/v8/multisig" + multisig9 "github.com/filecoin-project/go-state-types/builtin/v9/multisig" + "github.com/zondax/fil-parser/tools" ) func ChangeOwnerAddressValue(height int64, txMetadata string) (interface{}, error) { - switch height { - case 11: + switch { + case tools.V8.IsSupported(height): + return parse[*ChangeOwnerAddressParams, string](txMetadata, jsonUnmarshaller[*ChangeOwnerAddressParams]) + case tools.V9.IsSupported(height): + return parse[*ChangeOwnerAddressParams, string](txMetadata, jsonUnmarshaller[*ChangeOwnerAddressParams]) + case tools.V10.IsSupported(height): + return parse[*ChangeOwnerAddressParams, string](txMetadata, jsonUnmarshaller[*ChangeOwnerAddressParams]) + case tools.V11.IsSupported(height): + return parse[*ChangeOwnerAddressParams, string](txMetadata, jsonUnmarshaller[*ChangeOwnerAddressParams]) + case tools.V12.IsSupported(height): + return parse[*ChangeOwnerAddressParams, string](txMetadata, jsonUnmarshaller[*ChangeOwnerAddressParams]) + case tools.V13.IsSupported(height): + return parse[*ChangeOwnerAddressParams, string](txMetadata, jsonUnmarshaller[*ChangeOwnerAddressParams]) + case tools.V14.IsSupported(height): + return parse[*ChangeOwnerAddressParams, string](txMetadata, jsonUnmarshaller[*ChangeOwnerAddressParams]) + case tools.V15.IsSupported(height): return parse[*ChangeOwnerAddressParams, string](txMetadata, jsonUnmarshaller[*ChangeOwnerAddressParams]) } return nil, nil } func ParseWithdrawBalanceValue(height int64, txMetadata string) (interface{}, error) { - switch height { - case 11: + switch { + case tools.V8.IsSupported(height): + return parse[*miner11.WithdrawBalanceParams, string](txMetadata, jsonUnmarshaller[*miner11.WithdrawBalanceParams]) + case tools.V9.IsSupported(height): + return parse[*miner11.WithdrawBalanceParams, string](txMetadata, jsonUnmarshaller[*miner11.WithdrawBalanceParams]) + case tools.V10.IsSupported(height): + return parse[*miner11.WithdrawBalanceParams, string](txMetadata, jsonUnmarshaller[*miner11.WithdrawBalanceParams]) + case tools.V11.IsSupported(height): + return parse[*miner11.WithdrawBalanceParams, string](txMetadata, jsonUnmarshaller[*miner11.WithdrawBalanceParams]) + case tools.V12.IsSupported(height): + return parse[*miner11.WithdrawBalanceParams, string](txMetadata, jsonUnmarshaller[*miner11.WithdrawBalanceParams]) + case tools.V13.IsSupported(height): + return parse[*miner11.WithdrawBalanceParams, string](txMetadata, jsonUnmarshaller[*miner11.WithdrawBalanceParams]) + case tools.V14.IsSupported(height): + return parse[*miner11.WithdrawBalanceParams, string](txMetadata, jsonUnmarshaller[*miner11.WithdrawBalanceParams]) + case tools.V15.IsSupported(height): return parse[*miner11.WithdrawBalanceParams, string](txMetadata, jsonUnmarshaller[*miner11.WithdrawBalanceParams]) } return nil, nil } func ParseInvokeContractValue(height int64, txMetadata string) (interface{}, error) { - switch height { - case 11: + switch { + case tools.V8.IsSupported(height): + return parse[*InvokeContractParams, string](txMetadata, jsonUnmarshaller[*InvokeContractParams]) + case tools.V9.IsSupported(height): + return parse[*InvokeContractParams, string](txMetadata, jsonUnmarshaller[*InvokeContractParams]) + case tools.V10.IsSupported(height): + return parse[*InvokeContractParams, string](txMetadata, jsonUnmarshaller[*InvokeContractParams]) + case tools.V11.IsSupported(height): + return parse[*InvokeContractParams, string](txMetadata, jsonUnmarshaller[*InvokeContractParams]) + case tools.V12.IsSupported(height): + return parse[*InvokeContractParams, string](txMetadata, jsonUnmarshaller[*InvokeContractParams]) + case tools.V13.IsSupported(height): + return parse[*InvokeContractParams, string](txMetadata, jsonUnmarshaller[*InvokeContractParams]) + case tools.V14.IsSupported(height): + return parse[*InvokeContractParams, string](txMetadata, jsonUnmarshaller[*InvokeContractParams]) + case tools.V15.IsSupported(height): return parse[*InvokeContractParams, string](txMetadata, jsonUnmarshaller[*InvokeContractParams]) } return nil, nil } func ParseAddSignerValue(height int64, txMetadata string) (interface{}, error) { - switch height { - case 11: + switch { + case tools.V8.IsSupported(height): + return parse[*multisig11.AddSignerParams, string](txMetadata, jsonUnmarshaller[*multisig11.AddSignerParams]) + case tools.V9.IsSupported(height): + return parse[*multisig9.AddSignerParams, string](txMetadata, jsonUnmarshaller[*multisig9.AddSignerParams]) + case tools.V10.IsSupported(height): + return parse[*multisig10.AddSignerParams, string](txMetadata, jsonUnmarshaller[*multisig10.AddSignerParams]) + case tools.V11.IsSupported(height): return parse[*multisig11.AddSignerParams, string](txMetadata, jsonUnmarshaller[*multisig11.AddSignerParams]) + case tools.V12.IsSupported(height): + return parse[*multisig12.AddSignerParams, string](txMetadata, jsonUnmarshaller[*multisig12.AddSignerParams]) + case tools.V13.IsSupported(height): + return parse[*multisig13.AddSignerParams, string](txMetadata, jsonUnmarshaller[*multisig13.AddSignerParams]) + case tools.V14.IsSupported(height): + return parse[*multisig14.AddSignerParams, string](txMetadata, jsonUnmarshaller[*multisig14.AddSignerParams]) + case tools.V15.IsSupported(height): + return parse[*multisig15.AddSignerParams, string](txMetadata, jsonUnmarshaller[*multisig15.AddSignerParams]) } return nil, nil } func ParseApproveValue(height int64, txMetadata string) (interface{}, error) { - switch height { - case 11: + switch { + case tools.V8.IsSupported(height): + if data, err := parse[metadataWithCbor, string](txMetadata, jsonUnmarshaller[metadataWithCbor]); err != nil { + return nil, err + } else { + return getApproveReturn(height, data) + } + case tools.V9.IsSupported(height): + if data, err := parse[metadataWithCbor, string](txMetadata, jsonUnmarshaller[metadataWithCbor]); err != nil { + return nil, err + } else { + return getApproveReturn(height, data) + } + case tools.V10.IsSupported(height): + if data, err := parse[metadataWithCbor, string](txMetadata, jsonUnmarshaller[metadataWithCbor]); err != nil { + return nil, err + } else { + return getApproveReturn(height, data) + } + case tools.V11.IsSupported(height): + if data, err := parse[metadataWithCbor, string](txMetadata, jsonUnmarshaller[metadataWithCbor]); err != nil { + return nil, err + } else { + return getApproveReturn(height, data) + } + case tools.V12.IsSupported(height): + if data, err := parse[metadataWithCbor, string](txMetadata, jsonUnmarshaller[metadataWithCbor]); err != nil { + return nil, err + } else { + return getApproveReturn(height, data) + } + case tools.V13.IsSupported(height): + if data, err := parse[metadataWithCbor, string](txMetadata, jsonUnmarshaller[metadataWithCbor]); err != nil { + return nil, err + } else { + return getApproveReturn(height, data) + } + case tools.V14.IsSupported(height): + if data, err := parse[metadataWithCbor, string](txMetadata, jsonUnmarshaller[metadataWithCbor]); err != nil { + return nil, err + } else { + return getApproveReturn(height, data) + } + case tools.V15.IsSupported(height): if data, err := parse[metadataWithCbor, string](txMetadata, jsonUnmarshaller[metadataWithCbor]); err != nil { return nil, err } else { @@ -54,8 +158,50 @@ func ParseApproveValue(height int64, txMetadata string) (interface{}, error) { } func ParseCancelValue(height int64, txMetadata string) (interface{}, error) { - switch height { - case 11: + switch { + case tools.V8.IsSupported(height): + if data, err := parse[metadataWithCbor, string](txMetadata, jsonUnmarshaller[metadataWithCbor]); err != nil { + return nil, err + } else { + return getCancelReturn(height, data) + } + case tools.V9.IsSupported(height): + if data, err := parse[metadataWithCbor, string](txMetadata, jsonUnmarshaller[metadataWithCbor]); err != nil { + return nil, err + } else { + return getCancelReturn(height, data) + } + case tools.V10.IsSupported(height): + if data, err := parse[metadataWithCbor, string](txMetadata, jsonUnmarshaller[metadataWithCbor]); err != nil { + return nil, err + } else { + return getCancelReturn(height, data) + } + case tools.V11.IsSupported(height): + if data, err := parse[metadataWithCbor, string](txMetadata, jsonUnmarshaller[metadataWithCbor]); err != nil { + return nil, err + } else { + return getCancelReturn(height, data) + } + case tools.V12.IsSupported(height): + if data, err := parse[metadataWithCbor, string](txMetadata, jsonUnmarshaller[metadataWithCbor]); err != nil { + return nil, err + } else { + return getCancelReturn(height, data) + } + case tools.V13.IsSupported(height): + if data, err := parse[metadataWithCbor, string](txMetadata, jsonUnmarshaller[metadataWithCbor]); err != nil { + return nil, err + } else { + return getCancelReturn(height, data) + } + case tools.V14.IsSupported(height): + if data, err := parse[metadataWithCbor, string](txMetadata, jsonUnmarshaller[metadataWithCbor]); err != nil { + return nil, err + } else { + return getCancelReturn(height, data) + } + case tools.V15.IsSupported(height): if data, err := parse[metadataWithCbor, string](txMetadata, jsonUnmarshaller[metadataWithCbor]); err != nil { return nil, err } else { @@ -66,61 +212,229 @@ func ParseCancelValue(height int64, txMetadata string) (interface{}, error) { } func ChangeNumApprovalsThresholdValue(height int64, txMetadata string) (interface{}, error) { - switch height { - case 11: + switch { + case tools.V8.IsSupported(height): + return parse[*multisig8.ChangeNumApprovalsThresholdParams, string](txMetadata, jsonUnmarshaller[*multisig8.ChangeNumApprovalsThresholdParams]) + case tools.V9.IsSupported(height): + return parse[*multisig9.ChangeNumApprovalsThresholdParams, string](txMetadata, jsonUnmarshaller[*multisig9.ChangeNumApprovalsThresholdParams]) + case tools.V10.IsSupported(height): + return parse[*multisig10.ChangeNumApprovalsThresholdParams, string](txMetadata, jsonUnmarshaller[*multisig10.ChangeNumApprovalsThresholdParams]) + case tools.V11.IsSupported(height): return parse[*multisig11.ChangeNumApprovalsThresholdParams, string](txMetadata, jsonUnmarshaller[*multisig11.ChangeNumApprovalsThresholdParams]) + case tools.V12.IsSupported(height): + return parse[*multisig12.ChangeNumApprovalsThresholdParams, string](txMetadata, jsonUnmarshaller[*multisig12.ChangeNumApprovalsThresholdParams]) + case tools.V13.IsSupported(height): + return parse[*multisig13.ChangeNumApprovalsThresholdParams, string](txMetadata, jsonUnmarshaller[*multisig13.ChangeNumApprovalsThresholdParams]) + case tools.V14.IsSupported(height): + return parse[*multisig14.ChangeNumApprovalsThresholdParams, string](txMetadata, jsonUnmarshaller[*multisig14.ChangeNumApprovalsThresholdParams]) + case tools.V15.IsSupported(height): + return parse[*multisig15.ChangeNumApprovalsThresholdParams, string](txMetadata, jsonUnmarshaller[*multisig15.ChangeNumApprovalsThresholdParams]) } return nil, nil } func ParseConstructorValue(height int64, txMetadata string) (interface{}, error) { - switch height { - case 11: + switch { + case tools.V8.IsSupported(height): + if data, err := parse[*multisig8.ConstructorParams, string](txMetadata, jsonUnmarshaller[*multisig8.ConstructorParams]); err != nil { + return nil, err + } else { + return getValue[*multisig8.ConstructorParams](height, data) + } + case tools.V9.IsSupported(height): + if data, err := parse[*multisig9.ConstructorParams, string](txMetadata, jsonUnmarshaller[*multisig9.ConstructorParams]); err != nil { + return nil, err + } else { + return getValue[*multisig9.ConstructorParams](height, data) + } + case tools.V10.IsSupported(height): + if data, err := parse[*multisig10.ConstructorParams, string](txMetadata, jsonUnmarshaller[*multisig10.ConstructorParams]); err != nil { + return nil, err + } else { + return getValue[*multisig10.ConstructorParams](height, data) + } + case tools.V11.IsSupported(height): if data, err := parse[*multisig11.ConstructorParams, string](txMetadata, jsonUnmarshaller[*multisig11.ConstructorParams]); err != nil { return nil, err } else { return getValue[*multisig11.ConstructorParams](height, data) } + case tools.V12.IsSupported(height): + if data, err := parse[*multisig12.ConstructorParams, string](txMetadata, jsonUnmarshaller[*multisig12.ConstructorParams]); err != nil { + return nil, err + } else { + return getValue[*multisig12.ConstructorParams](height, data) + } + case tools.V13.IsSupported(height): + if data, err := parse[*multisig13.ConstructorParams, string](txMetadata, jsonUnmarshaller[*multisig13.ConstructorParams]); err != nil { + return nil, err + } else { + return getValue[*multisig13.ConstructorParams](height, data) + } + case tools.V14.IsSupported(height): + if data, err := parse[*multisig14.ConstructorParams, string](txMetadata, jsonUnmarshaller[*multisig14.ConstructorParams]); err != nil { + return nil, err + } else { + return getValue[*multisig14.ConstructorParams](height, data) + } + case tools.V15.IsSupported(height): + if data, err := parse[*multisig15.ConstructorParams, string](txMetadata, jsonUnmarshaller[*multisig15.ConstructorParams]); err != nil { + return nil, err + } else { + return getValue[*multisig15.ConstructorParams](height, data) + } } return nil, nil } func ParseLockBalanceValue(height int64, txMetadata string) (interface{}, error) { - switch height { - case 11: + switch { + case tools.V8.IsSupported(height): + if data, err := parse[*multisig8.LockBalanceParams, string](txMetadata, jsonUnmarshaller[*multisig8.LockBalanceParams]); err != nil { + return nil, err + } else { + return getValue[*multisig8.LockBalanceParams](height, data) + } + case tools.V9.IsSupported(height): + if data, err := parse[*multisig9.LockBalanceParams, string](txMetadata, jsonUnmarshaller[*multisig9.LockBalanceParams]); err != nil { + return nil, err + } else { + return getValue[*multisig9.LockBalanceParams](height, data) + } + case tools.V10.IsSupported(height): + if data, err := parse[*multisig10.LockBalanceParams, string](txMetadata, jsonUnmarshaller[*multisig10.LockBalanceParams]); err != nil { + return nil, err + } else { + return getValue[*multisig10.LockBalanceParams](height, data) + } + case tools.V11.IsSupported(height): if data, err := parse[*multisig11.LockBalanceParams, string](txMetadata, jsonUnmarshaller[*multisig11.LockBalanceParams]); err != nil { return nil, err } else { return getValue[*multisig11.LockBalanceParams](height, data) } + case tools.V12.IsSupported(height): + if data, err := parse[*multisig12.LockBalanceParams, string](txMetadata, jsonUnmarshaller[*multisig12.LockBalanceParams]); err != nil { + return nil, err + } else { + return getValue[*multisig12.LockBalanceParams](height, data) + } + case tools.V13.IsSupported(height): + if data, err := parse[*multisig13.LockBalanceParams, string](txMetadata, jsonUnmarshaller[*multisig13.LockBalanceParams]); err != nil { + return nil, err + } else { + return getValue[*multisig13.LockBalanceParams](height, data) + } + case tools.V14.IsSupported(height): + if data, err := parse[*multisig14.LockBalanceParams, string](txMetadata, jsonUnmarshaller[*multisig14.LockBalanceParams]); err != nil { + return nil, err + } else { + return getValue[*multisig14.LockBalanceParams](height, data) + } + case tools.V15.IsSupported(height): + if data, err := parse[*multisig15.LockBalanceParams, string](txMetadata, jsonUnmarshaller[*multisig15.LockBalanceParams]); err != nil { + return nil, err + } else { + return getValue[*multisig15.LockBalanceParams](height, data) + } } return nil, nil } func ParseRemoveSignerValue(height int64, txMetadata string) (interface{}, error) { - switch height { - case 11: + switch { + case tools.V8.IsSupported(height): + if data, err := parse[*multisig8.RemoveSignerParams, string](txMetadata, jsonUnmarshaller[*multisig8.RemoveSignerParams]); err != nil { + return nil, err + } else { + return getValue[*multisig8.RemoveSignerParams](height, data) + } + case tools.V9.IsSupported(height): + if data, err := parse[*multisig9.RemoveSignerParams, string](txMetadata, jsonUnmarshaller[*multisig9.RemoveSignerParams]); err != nil { + return nil, err + } else { + return getValue[*multisig9.RemoveSignerParams](height, data) + } + case tools.V10.IsSupported(height): + if data, err := parse[*multisig10.RemoveSignerParams, string](txMetadata, jsonUnmarshaller[*multisig10.RemoveSignerParams]); err != nil { + return nil, err + } else { + return getValue[*multisig10.RemoveSignerParams](height, data) + } + case tools.V11.IsSupported(height): if data, err := parse[*multisig11.RemoveSignerParams, string](txMetadata, jsonUnmarshaller[*multisig11.RemoveSignerParams]); err != nil { return nil, err } else { return getValue[*multisig11.RemoveSignerParams](height, data) } + case tools.V12.IsSupported(height): + if data, err := parse[*multisig12.RemoveSignerParams, string](txMetadata, jsonUnmarshaller[*multisig12.RemoveSignerParams]); err != nil { + return nil, err + } else { + return getValue[*multisig12.RemoveSignerParams](height, data) + } + case tools.V13.IsSupported(height): + if data, err := parse[*multisig13.RemoveSignerParams, string](txMetadata, jsonUnmarshaller[*multisig13.RemoveSignerParams]); err != nil { + return nil, err + } else { + return getValue[*multisig13.RemoveSignerParams](height, data) + } + case tools.V14.IsSupported(height): + if data, err := parse[*multisig14.RemoveSignerParams, string](txMetadata, jsonUnmarshaller[*multisig14.RemoveSignerParams]); err != nil { + return nil, err + } else { + return getValue[*multisig14.RemoveSignerParams](height, data) + } + case tools.V15.IsSupported(height): + if data, err := parse[*multisig15.RemoveSignerParams, string](txMetadata, jsonUnmarshaller[*multisig15.RemoveSignerParams]); err != nil { + return nil, err + } else { + return getValue[*multisig15.RemoveSignerParams](height, data) + } } return nil, nil } func ParseSendValue(height int64, txMetadata string) (interface{}, error) { - switch height { - case 11: + switch { + case tools.V8.IsSupported(height): + return parse[*SendValue, string](txMetadata, jsonUnmarshaller[*SendValue]) + case tools.V9.IsSupported(height): + return parse[*SendValue, string](txMetadata, jsonUnmarshaller[*SendValue]) + case tools.V10.IsSupported(height): + return parse[*SendValue, string](txMetadata, jsonUnmarshaller[*SendValue]) + case tools.V11.IsSupported(height): + return parse[*SendValue, string](txMetadata, jsonUnmarshaller[*SendValue]) + case tools.V12.IsSupported(height): + return parse[*SendValue, string](txMetadata, jsonUnmarshaller[*SendValue]) + case tools.V13.IsSupported(height): + return parse[*SendValue, string](txMetadata, jsonUnmarshaller[*SendValue]) + case tools.V14.IsSupported(height): + return parse[*SendValue, string](txMetadata, jsonUnmarshaller[*SendValue]) + case tools.V15.IsSupported(height): return parse[*SendValue, string](txMetadata, jsonUnmarshaller[*SendValue]) } return nil, nil } func ParseSwapSignerValue(height int64, txMetadata string) (interface{}, error) { - switch height { - case 11: + switch { + case tools.V8.IsSupported(height): + return parse[*multisig8.SwapSignerParams, string](txMetadata, jsonUnmarshaller[*multisig8.SwapSignerParams]) + case tools.V9.IsSupported(height): + return parse[*multisig9.SwapSignerParams, string](txMetadata, jsonUnmarshaller[*multisig9.SwapSignerParams]) + case tools.V10.IsSupported(height): + return parse[*multisig10.SwapSignerParams, string](txMetadata, jsonUnmarshaller[*multisig10.SwapSignerParams]) + case tools.V11.IsSupported(height): return parse[*multisig11.SwapSignerParams, string](txMetadata, jsonUnmarshaller[*multisig11.SwapSignerParams]) + case tools.V12.IsSupported(height): + return parse[*multisig12.SwapSignerParams, string](txMetadata, jsonUnmarshaller[*multisig12.SwapSignerParams]) + case tools.V13.IsSupported(height): + return parse[*multisig13.SwapSignerParams, string](txMetadata, jsonUnmarshaller[*multisig13.SwapSignerParams]) + case tools.V14.IsSupported(height): + return parse[*multisig14.SwapSignerParams, string](txMetadata, jsonUnmarshaller[*multisig14.SwapSignerParams]) + case tools.V15.IsSupported(height): + return parse[*multisig15.SwapSignerParams, string](txMetadata, jsonUnmarshaller[*multisig15.SwapSignerParams]) } return nil, nil } @@ -146,83 +460,3 @@ func ParseUniversalReceiverHookValue(height int64, txMetadata string) (interface return result, nil } - -func getApproveReturn(height int64, raw map[string]interface{}) (interface{}, error) { - var params ApproveValue - - returnRaw, ok := raw["Return"].(map[string]interface{}) - if !ok { - return nil, fmt.Errorf("Return not found or not a map") - } - - applied, ok := returnRaw["Applied"].(bool) - if !ok { - return nil, fmt.Errorf("Applied not found or not a bool") - } - - code, ok := returnRaw["Code"].(float64) - if !ok { - return nil, fmt.Errorf("Code not found or not a float64") - } - - ret, ok := returnRaw["Ret"].(string) - if !ok { - return nil, fmt.Errorf("Ret not found or not a string") - } - - switch height { - case 11: - params.Return = multisig11.ApproveReturn{ - Applied: applied, - Code: exitcode.ExitCode(code), - Ret: []byte(ret), - } - } - - return params, nil - -} - -func getCancelReturn(height int64, raw map[string]interface{}) (interface{}, error) { - paramsStr, ok := raw["Params"].(string) - if !ok { - return nil, fmt.Errorf("Params not found or not a string") - } - - var paramsRaw map[string]interface{} - err := json.Unmarshal([]byte(paramsStr), ¶msRaw) - if err != nil { - return nil, err - } - - var v CancelValue - err = mapToStruct(paramsRaw, &v) - if err != nil { - return nil, err - } - - return v, nil -} - -func getChangeNumApprovalsThresholdValue(height int64, raw map[string]interface{}) (interface{}, error) { - paramsStr, ok := raw["Params"].(map[string]interface{}) - if !ok { - return nil, fmt.Errorf("Params not found or not a map") - } - - var newValue uint64 - if newThreshold, ok := paramsStr["NewThreshold"].(float64); ok { - newValue = uint64(newThreshold) - } else { - return nil, fmt.Errorf("NewThreshold not found or not a number") - } - var v any - switch height { - case 11: - v = multisig11.ChangeNumApprovalsThresholdParams{ - NewThreshold: newValue, - } - } - - return v, nil -} diff --git a/actors/multisig/verifier.go b/actors/multisig/verifier.go index 6ede15be..7617c163 100644 --- a/actors/multisig/verifier.go +++ b/actors/multisig/verifier.go @@ -1,11 +1,35 @@ package multisig -import verifreg11 "github.com/filecoin-project/go-state-types/builtin/v11/verifreg" +import ( + verifreg10 "github.com/filecoin-project/go-state-types/builtin/v10/verifreg" + verifreg11 "github.com/filecoin-project/go-state-types/builtin/v11/verifreg" + verifreg12 "github.com/filecoin-project/go-state-types/builtin/v12/verifreg" + verifreg13 "github.com/filecoin-project/go-state-types/builtin/v13/verifreg" + verifreg14 "github.com/filecoin-project/go-state-types/builtin/v14/verifreg" + verifreg15 "github.com/filecoin-project/go-state-types/builtin/v15/verifreg" + verifreg8 "github.com/filecoin-project/go-state-types/builtin/v8/verifreg" + verifreg9 "github.com/filecoin-project/go-state-types/builtin/v9/verifreg" + "github.com/zondax/fil-parser/tools" +) func AddVerifierValue(height int64, txMetadata string) (interface{}, error) { - switch height { - case 11: + switch { + case tools.V8.IsSupported(height): + return parse[*verifreg8.AddVerifierParams, string](txMetadata, jsonUnmarshaller[*verifreg8.AddVerifierParams]) + case tools.V9.IsSupported(height): + return parse[*verifreg9.AddVerifierParams, string](txMetadata, jsonUnmarshaller[*verifreg9.AddVerifierParams]) + case tools.V10.IsSupported(height): + return parse[*verifreg10.AddVerifierParams, string](txMetadata, jsonUnmarshaller[*verifreg10.AddVerifierParams]) + case tools.V11.IsSupported(height): return parse[*verifreg11.AddVerifierParams, string](txMetadata, jsonUnmarshaller[*verifreg11.AddVerifierParams]) + case tools.V12.IsSupported(height): + return parse[*verifreg12.AddVerifierParams, string](txMetadata, jsonUnmarshaller[*verifreg12.AddVerifierParams]) + case tools.V13.IsSupported(height): + return parse[*verifreg13.AddVerifierParams, string](txMetadata, jsonUnmarshaller[*verifreg13.AddVerifierParams]) + case tools.V14.IsSupported(height): + return parse[*verifreg14.AddVerifierParams, string](txMetadata, jsonUnmarshaller[*verifreg14.AddVerifierParams]) + case tools.V15.IsSupported(height): + return parse[*verifreg15.AddVerifierParams, string](txMetadata, jsonUnmarshaller[*verifreg15.AddVerifierParams]) } return nil, nil } diff --git a/actors/paymentChannel/paymentChannel.go b/actors/paymentChannel/paymentChannel.go index 73e13e81..a5d1fefb 100644 --- a/actors/paymentChannel/paymentChannel.go +++ b/actors/paymentChannel/paymentChannel.go @@ -11,6 +11,7 @@ import ( paychv15 "github.com/filecoin-project/go-state-types/builtin/v15/paych" paychv8 "github.com/filecoin-project/go-state-types/builtin/v8/paych" paychv9 "github.com/filecoin-project/go-state-types/builtin/v9/paych" + "github.com/zondax/fil-parser/tools" ) type paymentChannelParams interface { @@ -18,44 +19,44 @@ type paymentChannelParams interface { } func PaymentChannelConstructor(height int64, raw []byte) (map[string]interface{}, error) { - switch height { - case 8: + switch { + case tools.V8.IsSupported(height): return parse[*paychv8.ConstructorParams](raw) - case 9: + case tools.V9.IsSupported(height): return parse[*paychv9.ConstructorParams](raw) - case 10: + case tools.V10.IsSupported(height): return parse[*paychv10.ConstructorParams](raw) - case 11: + case tools.V11.IsSupported(height): return parse[*paychv11.ConstructorParams](raw) - case 12: + case tools.V12.IsSupported(height): return parse[*paychv12.ConstructorParams](raw) - case 13: + case tools.V13.IsSupported(height): return parse[*paychv13.ConstructorParams](raw) - case 14: + case tools.V14.IsSupported(height): return parse[*paychv14.ConstructorParams](raw) - case 15: + case tools.V15.IsSupported(height): return parse[*paychv15.ConstructorParams](raw) } return nil, nil } func UpdateChannelState(height int64, raw []byte) (map[string]interface{}, error) { - switch height { - case 8: + switch { + case tools.V8.IsSupported(height): return parse[*paychv8.UpdateChannelStateParams](raw) - case 9: + case tools.V9.IsSupported(height): return parse[*paychv9.UpdateChannelStateParams](raw) - case 10: + case tools.V10.IsSupported(height): return parse[*paychv10.UpdateChannelStateParams](raw) - case 11: + case tools.V11.IsSupported(height): return parse[*paychv11.UpdateChannelStateParams](raw) - case 12: + case tools.V12.IsSupported(height): return parse[*paychv12.UpdateChannelStateParams](raw) - case 13: + case tools.V13.IsSupported(height): return parse[*paychv13.UpdateChannelStateParams](raw) - case 14: + case tools.V14.IsSupported(height): return parse[*paychv14.UpdateChannelStateParams](raw) - case 15: + case tools.V15.IsSupported(height): return parse[*paychv15.UpdateChannelStateParams](raw) } return nil, nil diff --git a/actors/power/power.go b/actors/power/power.go index e1ddbceb..d4409607 100644 --- a/actors/power/power.go +++ b/actors/power/power.go @@ -2,20 +2,45 @@ package power import ( "github.com/filecoin-project/go-state-types/abi" + powerv10 "github.com/filecoin-project/go-state-types/builtin/v10/power" + powerv11 "github.com/filecoin-project/go-state-types/builtin/v11/power" + powerv12 "github.com/filecoin-project/go-state-types/builtin/v12/power" + powerv13 "github.com/filecoin-project/go-state-types/builtin/v13/power" + powerv14 "github.com/filecoin-project/go-state-types/builtin/v14/power" + powerv15 "github.com/filecoin-project/go-state-types/builtin/v15/power" powerv8 "github.com/filecoin-project/go-state-types/builtin/v8/power" powerv9 "github.com/filecoin-project/go-state-types/builtin/v9/power" "github.com/filecoin-project/go-state-types/proof" "github.com/zondax/fil-parser/parser" + "github.com/zondax/fil-parser/tools" ) func CurrentTotalPower(msg *parser.LotusMessage, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { - switch height { - case 8: + switch { + case tools.V8.IsSupported(height): data, _, err := parse[*powerv8.CurrentTotalPowerReturn, *powerv8.CurrentTotalPowerReturn](msg, raw, rawReturn, false) return data, err - case 9: + case tools.V9.IsSupported(height): data, _, err := parse[*powerv9.CurrentTotalPowerReturn, *powerv9.CurrentTotalPowerReturn](msg, raw, rawReturn, false) return data, err + case tools.V10.IsSupported(height): + data, _, err := parse[*powerv10.CurrentTotalPowerReturn, *powerv10.CurrentTotalPowerReturn](msg, raw, rawReturn, false) + return data, err + case tools.V11.IsSupported(height): + data, _, err := parse[*powerv11.CurrentTotalPowerReturn, *powerv11.CurrentTotalPowerReturn](msg, raw, rawReturn, false) + return data, err + case tools.V12.IsSupported(height): + data, _, err := parse[*powerv12.CurrentTotalPowerReturn, *powerv12.CurrentTotalPowerReturn](msg, raw, rawReturn, false) + return data, err + case tools.V13.IsSupported(height): + data, _, err := parse[*powerv13.CurrentTotalPowerReturn, *powerv13.CurrentTotalPowerReturn](msg, raw, rawReturn, false) + return data, err + case tools.V14.IsSupported(height): + data, _, err := parse[*powerv14.CurrentTotalPowerReturn, *powerv14.CurrentTotalPowerReturn](msg, raw, rawReturn, false) + return data, err + case tools.V15.IsSupported(height): + data, _, err := parse[*powerv15.CurrentTotalPowerReturn, *powerv15.CurrentTotalPowerReturn](msg, raw, rawReturn, false) + return data, err } return nil, nil } @@ -26,44 +51,149 @@ func SubmitPoRepForBulkVerify(msg *parser.LotusMessage, height int64, raw, rawRe } func PowerConstructor(height int64, msg *parser.LotusMessage, raw []byte) (map[string]interface{}, error) { - switch height { - case 8: + switch { + case tools.V8.IsSupported(height): data, _, err := parse[*powerv8.MinerConstructorParams, *powerv8.MinerConstructorParams](msg, raw, nil, false) return data, err + case tools.V9.IsSupported(height): + data, _, err := parse[*powerv9.MinerConstructorParams, *powerv9.MinerConstructorParams](msg, raw, nil, false) + return data, err + case tools.V10.IsSupported(height): + data, _, err := parse[*powerv10.MinerConstructorParams, *powerv10.MinerConstructorParams](msg, raw, nil, false) + return data, err + case tools.V11.IsSupported(height): + data, _, err := parse[*powerv11.MinerConstructorParams, *powerv11.MinerConstructorParams](msg, raw, nil, false) + return data, err + case tools.V12.IsSupported(height): + data, _, err := parse[*powerv12.MinerConstructorParams, *powerv12.MinerConstructorParams](msg, raw, nil, false) + return data, err + case tools.V13.IsSupported(height): + data, _, err := parse[*powerv13.MinerConstructorParams, *powerv13.MinerConstructorParams](msg, raw, nil, false) + return data, err + case tools.V14.IsSupported(height): + data, _, err := parse[*powerv14.MinerConstructorParams, *powerv14.MinerConstructorParams](msg, raw, nil, false) + return data, err + case tools.V15.IsSupported(height): + data, _, err := parse[*powerv15.MinerConstructorParams, *powerv15.MinerConstructorParams](msg, raw, nil, false) + return data, err } return nil, nil } func CreateMiner(msg *parser.LotusMessage, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { - switch height { - case 8: + switch { + case tools.V8.IsSupported(height): data, _, err := parse[*powerv8.CreateMinerParams, *powerv8.CreateMinerReturn](msg, raw, rawReturn, true) return data, err + case tools.V9.IsSupported(height): + data, _, err := parse[*powerv9.CreateMinerParams, *powerv9.CreateMinerReturn](msg, raw, rawReturn, true) + return data, err + case tools.V10.IsSupported(height): + data, _, err := parse[*powerv10.CreateMinerParams, *powerv10.CreateMinerReturn](msg, raw, rawReturn, true) + return data, err + case tools.V11.IsSupported(height): + data, _, err := parse[*powerv11.CreateMinerParams, *powerv11.CreateMinerReturn](msg, raw, rawReturn, true) + return data, err + case tools.V12.IsSupported(height): + data, _, err := parse[*powerv12.CreateMinerParams, *powerv12.CreateMinerReturn](msg, raw, rawReturn, true) + return data, err + case tools.V13.IsSupported(height): + data, _, err := parse[*powerv13.CreateMinerParams, *powerv13.CreateMinerReturn](msg, raw, rawReturn, true) + return data, err + case tools.V14.IsSupported(height): + data, _, err := parse[*powerv14.CreateMinerParams, *powerv14.CreateMinerReturn](msg, raw, rawReturn, true) + return data, err + case tools.V15.IsSupported(height): + data, _, err := parse[*powerv15.CreateMinerParams, *powerv15.CreateMinerReturn](msg, raw, rawReturn, true) + return data, err } return nil, nil } func EnrollCronEvent(msg *parser.LotusMessage, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { - switch height { - case 8: + switch { + case tools.V8.IsSupported(height): data, _, err := parse[*powerv8.EnrollCronEventParams, *powerv8.EnrollCronEventParams](msg, raw, rawReturn, true) return data, err + case tools.V9.IsSupported(height): + data, _, err := parse[*powerv9.EnrollCronEventParams, *powerv9.EnrollCronEventParams](msg, raw, rawReturn, true) + return data, err + case tools.V10.IsSupported(height): + data, _, err := parse[*powerv10.EnrollCronEventParams, *powerv10.EnrollCronEventParams](msg, raw, rawReturn, true) + return data, err + case tools.V11.IsSupported(height): + data, _, err := parse[*powerv11.EnrollCronEventParams, *powerv11.EnrollCronEventParams](msg, raw, rawReturn, true) + return data, err + case tools.V12.IsSupported(height): + data, _, err := parse[*powerv12.EnrollCronEventParams, *powerv12.EnrollCronEventParams](msg, raw, rawReturn, true) + return data, err + case tools.V13.IsSupported(height): + data, _, err := parse[*powerv13.EnrollCronEventParams, *powerv13.EnrollCronEventParams](msg, raw, rawReturn, true) + return data, err + case tools.V14.IsSupported(height): + data, _, err := parse[*powerv14.EnrollCronEventParams, *powerv14.EnrollCronEventParams](msg, raw, rawReturn, true) + return data, err + case tools.V15.IsSupported(height): + data, _, err := parse[*powerv15.EnrollCronEventParams, *powerv15.EnrollCronEventParams](msg, raw, rawReturn, true) + return data, err } return nil, nil } func UpdateClaimedPower(msg *parser.LotusMessage, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { - switch height { - case 8: + switch { + case tools.V8.IsSupported(height): data, _, err := parse[*powerv8.UpdateClaimedPowerParams, *powerv8.UpdateClaimedPowerParams](msg, raw, rawReturn, true) return data, err + case tools.V9.IsSupported(height): + data, _, err := parse[*powerv9.UpdateClaimedPowerParams, *powerv9.UpdateClaimedPowerParams](msg, raw, rawReturn, true) + return data, err + case tools.V10.IsSupported(height): + data, _, err := parse[*powerv10.UpdateClaimedPowerParams, *powerv10.UpdateClaimedPowerParams](msg, raw, rawReturn, true) + return data, err + case tools.V11.IsSupported(height): + data, _, err := parse[*powerv11.UpdateClaimedPowerParams, *powerv11.UpdateClaimedPowerParams](msg, raw, rawReturn, true) + return data, err + case tools.V12.IsSupported(height): + data, _, err := parse[*powerv12.UpdateClaimedPowerParams, *powerv12.UpdateClaimedPowerParams](msg, raw, rawReturn, true) + return data, err + case tools.V13.IsSupported(height): + data, _, err := parse[*powerv13.UpdateClaimedPowerParams, *powerv13.UpdateClaimedPowerParams](msg, raw, rawReturn, true) + return data, err + case tools.V14.IsSupported(height): + data, _, err := parse[*powerv14.UpdateClaimedPowerParams, *powerv14.UpdateClaimedPowerParams](msg, raw, rawReturn, true) + return data, err + case tools.V15.IsSupported(height): + data, _, err := parse[*powerv15.UpdateClaimedPowerParams, *powerv15.UpdateClaimedPowerParams](msg, raw, rawReturn, true) + return data, err } return nil, nil } func UpdatePledgeTotal(msg *parser.LotusMessage, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { - switch height { - case 8: + switch { + case tools.V8.IsSupported(height): + data, _, err := parse[*abi.TokenAmount, *abi.TokenAmount](msg, raw, rawReturn, false) + return data, err + case tools.V9.IsSupported(height): + data, _, err := parse[*abi.TokenAmount, *abi.TokenAmount](msg, raw, rawReturn, false) + return data, err + case tools.V10.IsSupported(height): + data, _, err := parse[*abi.TokenAmount, *abi.TokenAmount](msg, raw, rawReturn, false) + return data, err + case tools.V11.IsSupported(height): + data, _, err := parse[*abi.TokenAmount, *abi.TokenAmount](msg, raw, rawReturn, false) + return data, err + case tools.V12.IsSupported(height): + data, _, err := parse[*abi.TokenAmount, *abi.TokenAmount](msg, raw, rawReturn, false) + return data, err + case tools.V13.IsSupported(height): + data, _, err := parse[*abi.TokenAmount, *abi.TokenAmount](msg, raw, rawReturn, false) + return data, err + case tools.V14.IsSupported(height): + data, _, err := parse[*abi.TokenAmount, *abi.TokenAmount](msg, raw, rawReturn, false) + return data, err + case tools.V15.IsSupported(height): data, _, err := parse[*abi.TokenAmount, *abi.TokenAmount](msg, raw, rawReturn, false) return data, err } @@ -71,37 +201,121 @@ func UpdatePledgeTotal(msg *parser.LotusMessage, height int64, raw, rawReturn [] } func NetworkRawPower(msg *parser.LotusMessage, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { - switch height { - case 8: + switch { + case tools.V8.IsSupported(height): data, _, err := parse[*powerv8.NetworkRawPowerReturn, *powerv8.NetworkRawPowerReturn](msg, raw, rawReturn, false) return data, err + case tools.V9.IsSupported(height): + data, _, err := parse[*powerv9.NetworkRawPowerReturn, *powerv9.NetworkRawPowerReturn](msg, raw, rawReturn, false) + return data, err + case tools.V10.IsSupported(height): + data, _, err := parse[*powerv10.NetworkRawPowerReturn, *powerv10.NetworkRawPowerReturn](msg, raw, rawReturn, false) + return data, err + case tools.V11.IsSupported(height): + data, _, err := parse[*powerv11.NetworkRawPowerReturn, *powerv11.NetworkRawPowerReturn](msg, raw, rawReturn, false) + return data, err + case tools.V12.IsSupported(height): + data, _, err := parse[*powerv12.NetworkRawPowerReturn, *powerv12.NetworkRawPowerReturn](msg, raw, rawReturn, false) + return data, err + case tools.V13.IsSupported(height): + data, _, err := parse[*powerv13.NetworkRawPowerReturn, *powerv13.NetworkRawPowerReturn](msg, raw, rawReturn, false) + return data, err + case tools.V14.IsSupported(height): + data, _, err := parse[*powerv14.NetworkRawPowerReturn, *powerv14.NetworkRawPowerReturn](msg, raw, rawReturn, false) + return data, err + case tools.V15.IsSupported(height): + data, _, err := parse[*powerv15.NetworkRawPowerReturn, *powerv15.NetworkRawPowerReturn](msg, raw, rawReturn, false) + return data, err } return nil, nil } func MinerRawPower(msg *parser.LotusMessage, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { - switch height { - case 8: + switch { + case tools.V8.IsSupported(height): data, _, err := parse[*powerv8.MinerRawPowerParams, *powerv8.MinerRawPowerReturn](msg, raw, rawReturn, true) return data, err + case tools.V9.IsSupported(height): + data, _, err := parse[*powerv9.MinerRawPowerParams, *powerv9.MinerRawPowerReturn](msg, raw, rawReturn, true) + return data, err + case tools.V10.IsSupported(height): + data, _, err := parse[*powerv10.MinerRawPowerParams, *powerv10.MinerRawPowerReturn](msg, raw, rawReturn, true) + return data, err + case tools.V11.IsSupported(height): + data, _, err := parse[*powerv11.MinerRawPowerParams, *powerv11.MinerRawPowerReturn](msg, raw, rawReturn, true) + return data, err + case tools.V12.IsSupported(height): + data, _, err := parse[*powerv12.MinerRawPowerParams, *powerv12.MinerRawPowerReturn](msg, raw, rawReturn, true) + return data, err + case tools.V13.IsSupported(height): + data, _, err := parse[*powerv13.MinerRawPowerParams, *powerv13.MinerRawPowerReturn](msg, raw, rawReturn, true) + return data, err + case tools.V14.IsSupported(height): + data, _, err := parse[*powerv14.MinerRawPowerParams, *powerv14.MinerRawPowerReturn](msg, raw, rawReturn, true) + return data, err + case tools.V15.IsSupported(height): + data, _, err := parse[*powerv15.MinerRawPowerParams, *powerv15.MinerRawPowerReturn](msg, raw, rawReturn, true) + return data, err } return nil, nil } func MinerCount(msg *parser.LotusMessage, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { - switch height { - case 8: + switch { + case tools.V8.IsSupported(height): data, _, err := parse[*powerv8.MinerCountReturn, *powerv8.MinerCountReturn](msg, raw, rawReturn, false) return data, err + case tools.V9.IsSupported(height): + data, _, err := parse[*powerv9.MinerCountReturn, *powerv9.MinerCountReturn](msg, raw, rawReturn, false) + return data, err + case tools.V10.IsSupported(height): + data, _, err := parse[*powerv10.MinerCountReturn, *powerv10.MinerCountReturn](msg, raw, rawReturn, false) + return data, err + case tools.V11.IsSupported(height): + data, _, err := parse[*powerv11.MinerCountReturn, *powerv11.MinerCountReturn](msg, raw, rawReturn, false) + return data, err + case tools.V12.IsSupported(height): + data, _, err := parse[*powerv12.MinerCountReturn, *powerv12.MinerCountReturn](msg, raw, rawReturn, false) + return data, err + case tools.V13.IsSupported(height): + data, _, err := parse[*powerv13.MinerCountReturn, *powerv13.MinerCountReturn](msg, raw, rawReturn, false) + return data, err + case tools.V14.IsSupported(height): + data, _, err := parse[*powerv14.MinerCountReturn, *powerv14.MinerCountReturn](msg, raw, rawReturn, false) + return data, err + case tools.V15.IsSupported(height): + data, _, err := parse[*powerv15.MinerCountReturn, *powerv15.MinerCountReturn](msg, raw, rawReturn, false) + return data, err } return nil, nil } func MinerConsensusCount(msg *parser.LotusMessage, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { - switch height { - case 8: + switch { + case tools.V8.IsSupported(height): data, _, err := parse[*powerv8.MinerConsensusCountReturn, *powerv8.MinerConsensusCountReturn](msg, raw, rawReturn, false) return data, err + case tools.V9.IsSupported(height): + data, _, err := parse[*powerv9.MinerConsensusCountReturn, *powerv9.MinerConsensusCountReturn](msg, raw, rawReturn, false) + return data, err + case tools.V10.IsSupported(height): + data, _, err := parse[*powerv10.MinerConsensusCountReturn, *powerv10.MinerConsensusCountReturn](msg, raw, rawReturn, false) + return data, err + case tools.V11.IsSupported(height): + data, _, err := parse[*powerv11.MinerConsensusCountReturn, *powerv11.MinerConsensusCountReturn](msg, raw, rawReturn, false) + return data, err + case tools.V12.IsSupported(height): + data, _, err := parse[*powerv12.MinerConsensusCountReturn, *powerv12.MinerConsensusCountReturn](msg, raw, rawReturn, false) + return data, err + case tools.V13.IsSupported(height): + data, _, err := parse[*powerv13.MinerConsensusCountReturn, *powerv13.MinerConsensusCountReturn](msg, raw, rawReturn, false) + return data, err + case tools.V14.IsSupported(height): + data, _, err := parse[*powerv14.MinerConsensusCountReturn, *powerv14.MinerConsensusCountReturn](msg, raw, rawReturn, false) + return data, err + case tools.V15.IsSupported(height): + data, _, err := parse[*powerv15.MinerConsensusCountReturn, *powerv15.MinerConsensusCountReturn](msg, raw, rawReturn, false) + return data, err } return nil, nil } diff --git a/actors/reward/reward.go b/actors/reward/reward.go index 281d84a7..18fe6384 100644 --- a/actors/reward/reward.go +++ b/actors/reward/reward.go @@ -2,8 +2,15 @@ package reward import ( "github.com/filecoin-project/go-state-types/abi" + rewardv10 "github.com/filecoin-project/go-state-types/builtin/v10/reward" rewardv11 "github.com/filecoin-project/go-state-types/builtin/v11/reward" + rewardv12 "github.com/filecoin-project/go-state-types/builtin/v12/reward" + rewardv13 "github.com/filecoin-project/go-state-types/builtin/v13/reward" + rewardv14 "github.com/filecoin-project/go-state-types/builtin/v14/reward" + rewardv15 "github.com/filecoin-project/go-state-types/builtin/v15/reward" rewardv8 "github.com/filecoin-project/go-state-types/builtin/v8/reward" + rewardv9 "github.com/filecoin-project/go-state-types/builtin/v9/reward" + "github.com/zondax/fil-parser/tools" ) func RewardConstructor(height int64, raw []byte) (map[string]interface{}, error) { @@ -11,11 +18,23 @@ func RewardConstructor(height int64, raw []byte) (map[string]interface{}, error) } func AwardBlockReward(height int64, raw []byte) (map[string]interface{}, error) { - switch height { - case 8: + switch { + case tools.V8.IsSupported(height): return parse[*rewardv8.AwardBlockRewardParams](raw) - case 11: + case tools.V9.IsSupported(height): + return parse[*rewardv9.AwardBlockRewardParams](raw) + case tools.V10.IsSupported(height): + return parse[*rewardv10.AwardBlockRewardParams](raw) + case tools.V11.IsSupported(height): return parse[*rewardv11.AwardBlockRewardParams](raw) + case tools.V12.IsSupported(height): + return parse[*rewardv12.AwardBlockRewardParams](raw) + case tools.V13.IsSupported(height): + return parse[*rewardv13.AwardBlockRewardParams](raw) + case tools.V14.IsSupported(height): + return parse[*rewardv14.AwardBlockRewardParams](raw) + case tools.V15.IsSupported(height): + return parse[*rewardv15.AwardBlockRewardParams](raw) } return nil, nil } @@ -25,11 +44,23 @@ func UpdateNetworkKPI(height int64, raw []byte) (map[string]interface{}, error) } func ThisEpochReward(height int64, raw []byte) (map[string]interface{}, error) { - switch height { - case 8: + switch { + case tools.V8.IsSupported(height): return parse[*rewardv8.ThisEpochRewardReturn](raw) - case 11: + case tools.V9.IsSupported(height): + return parse[*rewardv9.ThisEpochRewardReturn](raw) + case tools.V10.IsSupported(height): + return parse[*rewardv10.ThisEpochRewardReturn](raw) + case tools.V11.IsSupported(height): return parse[*rewardv11.ThisEpochRewardReturn](raw) + case tools.V12.IsSupported(height): + return parse[*rewardv12.ThisEpochRewardReturn](raw) + case tools.V13.IsSupported(height): + return parse[*rewardv13.ThisEpochRewardReturn](raw) + case tools.V14.IsSupported(height): + return parse[*rewardv14.ThisEpochRewardReturn](raw) + case tools.V15.IsSupported(height): + return parse[*rewardv15.ThisEpochRewardReturn](raw) } return nil, nil } diff --git a/actors/verifiedRegistry.go b/actors/verifiedRegistry.go index a51153d7..e182ece8 100644 --- a/actors/verifiedRegistry.go +++ b/actors/verifiedRegistry.go @@ -2,6 +2,7 @@ package actors import ( "bytes" + "github.com/filecoin-project/go-address" "github.com/filecoin-project/go-state-types/builtin/v11/verifreg" "github.com/zondax/fil-parser/parser" diff --git a/actors/verifiedRegistry/verifiedRegistry.go b/actors/verifiedRegistry/verifiedRegistry.go index 37ff596f..398a836b 100644 --- a/actors/verifiedRegistry/verifiedRegistry.go +++ b/actors/verifiedRegistry/verifiedRegistry.go @@ -2,16 +2,36 @@ package verifiedregistry import ( "github.com/filecoin-project/go-address" + verifregv10 "github.com/filecoin-project/go-state-types/builtin/v10/verifreg" verifregv11 "github.com/filecoin-project/go-state-types/builtin/v11/verifreg" + verifregv12 "github.com/filecoin-project/go-state-types/builtin/v12/verifreg" + verifregv13 "github.com/filecoin-project/go-state-types/builtin/v13/verifreg" + verifregv14 "github.com/filecoin-project/go-state-types/builtin/v14/verifreg" + verifregv15 "github.com/filecoin-project/go-state-types/builtin/v15/verifreg" verifregv8 "github.com/filecoin-project/go-state-types/builtin/v8/verifreg" + verifregv9 "github.com/filecoin-project/go-state-types/builtin/v9/verifreg" + + "github.com/zondax/fil-parser/tools" ) func AddVerifier(height int64, raw []byte) (map[string]interface{}, error) { - switch height { - case 8: + switch { + case tools.V8.IsSupported(height): return parse[*verifregv8.AddVerifierParams, *verifregv8.AddVerifierParams](raw, nil, false) - case 11: + case tools.V9.IsSupported(height): + return parse[*verifregv9.AddVerifierParams, *verifregv9.AddVerifierParams](raw, nil, false) + case tools.V10.IsSupported(height): + return parse[*verifregv10.AddVerifierParams, *verifregv10.AddVerifierParams](raw, nil, false) + case tools.V11.IsSupported(height): return parse[*verifregv11.AddVerifierParams, *verifregv11.AddVerifierParams](raw, nil, false) + case tools.V12.IsSupported(height): + return parse[*verifregv12.AddVerifierParams, *verifregv12.AddVerifierParams](raw, nil, false) + case tools.V13.IsSupported(height): + return parse[*verifregv13.AddVerifierParams, *verifregv13.AddVerifierParams](raw, nil, false) + case tools.V14.IsSupported(height): + return parse[*verifregv14.AddVerifierParams, *verifregv14.AddVerifierParams](raw, nil, false) + case tools.V15.IsSupported(height): + return parse[*verifregv15.AddVerifierParams, *verifregv15.AddVerifierParams](raw, nil, false) } return nil, nil } @@ -21,121 +41,265 @@ func RemoveVerifier(height int64, raw []byte) (map[string]interface{}, error) { } func AddVerifiedClient(height int64, raw []byte) (map[string]interface{}, error) { - switch height { - case 8: + switch { + case tools.V8.IsSupported(height): return parse[*verifregv8.AddVerifiedClientParams, *verifregv8.AddVerifiedClientParams](raw, nil, false) - case 11: + case tools.V9.IsSupported(height): + return parse[*verifregv9.AddVerifiedClientParams, *verifregv9.AddVerifiedClientParams](raw, nil, false) + case tools.V10.IsSupported(height): + return parse[*verifregv10.AddVerifiedClientParams, *verifregv10.AddVerifiedClientParams](raw, nil, false) + case tools.V11.IsSupported(height): return parse[*verifregv11.AddVerifiedClientParams, *verifregv11.AddVerifiedClientParams](raw, nil, false) + case tools.V12.IsSupported(height): + return parse[*verifregv12.AddVerifiedClientParams, *verifregv12.AddVerifiedClientParams](raw, nil, false) + case tools.V13.IsSupported(height): + return parse[*verifregv13.AddVerifiedClientParams, *verifregv13.AddVerifiedClientParams](raw, nil, false) + case tools.V14.IsSupported(height): + return parse[*verifregv14.AddVerifiedClientParams, *verifregv14.AddVerifiedClientParams](raw, nil, false) + case tools.V15.IsSupported(height): + return parse[*verifregv15.AddVerifiedClientParams, *verifregv15.AddVerifiedClientParams](raw, nil, false) } return nil, nil } func UseBytes(height int64, raw []byte) (map[string]interface{}, error) { - switch height { - case 8: + switch { + case tools.V8.IsSupported(height): return parse[*verifregv8.UseBytesParams, *verifregv8.UseBytesParams](raw, nil, false) - case 11: + case tools.V9.IsSupported(height): + return parse[*verifregv9.UseBytesParams, *verifregv9.UseBytesParams](raw, nil, false) + case tools.V10.IsSupported(height): + return parse[*verifregv10.UseBytesParams, *verifregv10.UseBytesParams](raw, nil, false) + case tools.V11.IsSupported(height): return parse[*verifregv11.UseBytesParams, *verifregv11.UseBytesParams](raw, nil, false) + case tools.V12.IsSupported(height): + return parse[*verifregv12.UseBytesParams, *verifregv12.UseBytesParams](raw, nil, false) + case tools.V13.IsSupported(height): + return parse[*verifregv13.UseBytesParams, *verifregv13.UseBytesParams](raw, nil, false) + case tools.V14.IsSupported(height): + return parse[*verifregv14.UseBytesParams, *verifregv14.UseBytesParams](raw, nil, false) + case tools.V15.IsSupported(height): + return parse[*verifregv15.UseBytesParams, *verifregv15.UseBytesParams](raw, nil, false) } return nil, nil } func RestoreBytes(height int64, raw []byte) (map[string]interface{}, error) { - switch height { - case 8: + switch { + case tools.V8.IsSupported(height): return parse[*verifregv8.RestoreBytesParams, *verifregv8.RestoreBytesParams](raw, nil, false) - case 11: + case tools.V9.IsSupported(height): + return parse[*verifregv9.RestoreBytesParams, *verifregv9.RestoreBytesParams](raw, nil, false) + case tools.V10.IsSupported(height): + return parse[*verifregv10.RestoreBytesParams, *verifregv10.RestoreBytesParams](raw, nil, false) + case tools.V11.IsSupported(height): return parse[*verifregv11.RestoreBytesParams, *verifregv11.RestoreBytesParams](raw, nil, false) + case tools.V12.IsSupported(height): + return parse[*verifregv12.RestoreBytesParams, *verifregv12.RestoreBytesParams](raw, nil, false) + case tools.V13.IsSupported(height): + return parse[*verifregv13.RestoreBytesParams, *verifregv13.RestoreBytesParams](raw, nil, false) + case tools.V14.IsSupported(height): + return parse[*verifregv14.RestoreBytesParams, *verifregv14.RestoreBytesParams](raw, nil, false) + case tools.V15.IsSupported(height): + return parse[*verifregv15.RestoreBytesParams, *verifregv15.RestoreBytesParams](raw, nil, false) } return nil, nil } func RemoveVerifiedClientDataCap(height int64, raw []byte) (map[string]interface{}, error) { - switch height { - case 8: + switch { + case tools.V8.IsSupported(height): return parse[*verifregv8.DataCap, *verifregv8.DataCap](raw, nil, false) - case 11: + case tools.V9.IsSupported(height): + return parse[*verifregv9.DataCap, *verifregv9.DataCap](raw, nil, false) + case tools.V10.IsSupported(height): + return parse[*verifregv10.DataCap, *verifregv10.DataCap](raw, nil, false) + case tools.V11.IsSupported(height): return parse[*verifregv11.DataCap, *verifregv11.DataCap](raw, nil, false) + case tools.V12.IsSupported(height): + return parse[*verifregv12.DataCap, *verifregv12.DataCap](raw, nil, false) + case tools.V13.IsSupported(height): + return parse[*verifregv13.DataCap, *verifregv13.DataCap](raw, nil, false) + case tools.V14.IsSupported(height): + return parse[*verifregv14.DataCap, *verifregv14.DataCap](raw, nil, false) + case tools.V15.IsSupported(height): + return parse[*verifregv15.DataCap, *verifregv15.DataCap](raw, nil, false) } return nil, nil } func RemoveExpiredAllocations(height int64, raw, rawReturn []byte) (map[string]interface{}, error) { - switch height { - case 8: + switch { + case tools.V8.IsSupported(height): return parse[*verifregv8.RemoveExpiredAllocationsParams, *verifregv8.RemoveExpiredAllocationsReturn](raw, rawReturn, true) - case 11: + case tools.V9.IsSupported(height): + return parse[*verifregv9.RemoveExpiredAllocationsParams, *verifregv9.RemoveExpiredAllocationsReturn](raw, rawReturn, true) + case tools.V10.IsSupported(height): + return parse[*verifregv10.RemoveExpiredAllocationsParams, *verifregv10.RemoveExpiredAllocationsReturn](raw, rawReturn, true) + case tools.V11.IsSupported(height): return parse[*verifregv11.RemoveExpiredAllocationsParams, *verifregv11.RemoveExpiredAllocationsReturn](raw, rawReturn, true) + case tools.V12.IsSupported(height): + return parse[*verifregv12.RemoveExpiredAllocationsParams, *verifregv12.RemoveExpiredAllocationsReturn](raw, rawReturn, true) + case tools.V13.IsSupported(height): + return parse[*verifregv13.RemoveExpiredAllocationsParams, *verifregv13.RemoveExpiredAllocationsReturn](raw, rawReturn, true) + case tools.V14.IsSupported(height): + return parse[*verifregv14.RemoveExpiredAllocationsParams, *verifregv14.RemoveExpiredAllocationsReturn](raw, rawReturn, true) + case tools.V15.IsSupported(height): + return parse[*verifregv15.RemoveExpiredAllocationsParams, *verifregv15.RemoveExpiredAllocationsReturn](raw, rawReturn, true) } return nil, nil } func Deprecated1(height int64, raw []byte) (map[string]interface{}, error) { - switch height { - case 8: + switch { + case tools.V8.IsSupported(height): return parse[*verifregv8.RestoreBytesParams, *verifregv8.RestoreBytesParams](raw, nil, false) - case 11: + case tools.V9.IsSupported(height): + return parse[*verifregv9.RestoreBytesParams, *verifregv9.RestoreBytesParams](raw, nil, false) + case tools.V10.IsSupported(height): + return parse[*verifregv10.RestoreBytesParams, *verifregv10.RestoreBytesParams](raw, nil, false) + case tools.V11.IsSupported(height): return parse[*verifregv11.RestoreBytesParams, *verifregv11.RestoreBytesParams](raw, nil, false) + case tools.V12.IsSupported(height): + return parse[*verifregv12.RestoreBytesParams, *verifregv12.RestoreBytesParams](raw, nil, false) + case tools.V13.IsSupported(height): + return parse[*verifregv13.RestoreBytesParams, *verifregv13.RestoreBytesParams](raw, nil, false) + case tools.V14.IsSupported(height): + return parse[*verifregv14.RestoreBytesParams, *verifregv14.RestoreBytesParams](raw, nil, false) + case tools.V15.IsSupported(height): + return parse[*verifregv15.RestoreBytesParams, *verifregv15.RestoreBytesParams](raw, nil, false) } return nil, nil } func Deprecated2(height int64, raw []byte) (map[string]interface{}, error) { - switch height { - case 8: + switch { + case tools.V8.IsSupported(height): return parse[*verifregv8.UseBytesParams, *verifregv8.UseBytesParams](raw, nil, false) - case 11: + case tools.V9.IsSupported(height): + return parse[*verifregv9.UseBytesParams, *verifregv9.UseBytesParams](raw, nil, false) + case tools.V10.IsSupported(height): + return parse[*verifregv10.UseBytesParams, *verifregv10.UseBytesParams](raw, nil, false) + case tools.V11.IsSupported(height): return parse[*verifregv11.UseBytesParams, *verifregv11.UseBytesParams](raw, nil, false) + case tools.V12.IsSupported(height): + return parse[*verifregv12.UseBytesParams, *verifregv12.UseBytesParams](raw, nil, false) + case tools.V13.IsSupported(height): + return parse[*verifregv13.UseBytesParams, *verifregv13.UseBytesParams](raw, nil, false) + case tools.V14.IsSupported(height): + return parse[*verifregv14.UseBytesParams, *verifregv14.UseBytesParams](raw, nil, false) + case tools.V15.IsSupported(height): + return parse[*verifregv15.UseBytesParams, *verifregv15.UseBytesParams](raw, nil, false) } return nil, nil } func ClaimAllocations(height int64, raw, rawReturn []byte) (map[string]interface{}, error) { - switch height { - case 8: + switch { + case tools.V8.IsSupported(height): return parse[*verifregv8.ClaimAllocationsParams, *verifregv8.ClaimAllocationsReturn](raw, rawReturn, true) - case 11: + case tools.V9.IsSupported(height): + return parse[*verifregv9.ClaimAllocationsParams, *verifregv9.ClaimAllocationsReturn](raw, rawReturn, true) + case tools.V10.IsSupported(height): + return parse[*verifregv10.ClaimAllocationsParams, *verifregv10.ClaimAllocationsReturn](raw, rawReturn, true) + case tools.V11.IsSupported(height): return parse[*verifregv11.ClaimAllocationsParams, *verifregv11.ClaimAllocationsReturn](raw, rawReturn, true) + case tools.V12.IsSupported(height): + return parse[*verifregv12.ClaimAllocationsParams, *verifregv12.ClaimAllocationsReturn](raw, rawReturn, true) + case tools.V13.IsSupported(height): + return parse[*verifregv13.ClaimAllocationsParams, *verifregv13.ClaimAllocationsReturn](raw, rawReturn, true) + case tools.V14.IsSupported(height): + return parse[*verifregv14.ClaimAllocationsParams, *verifregv14.ClaimAllocationsReturn](raw, rawReturn, true) + case tools.V15.IsSupported(height): + return parse[*verifregv15.ClaimAllocationsParams, *verifregv15.ClaimAllocationsReturn](raw, rawReturn, true) } return nil, nil } func GetClaims(height int64, raw, rawReturn []byte) (map[string]interface{}, error) { - switch height { - case 8: + switch { + case tools.V8.IsSupported(height): return parse[*verifregv8.GetClaimsParams, *verifregv8.GetClaimsReturn](raw, rawReturn, true) - case 11: + case tools.V9.IsSupported(height): + return parse[*verifregv9.GetClaimsParams, *verifregv9.GetClaimsReturn](raw, rawReturn, true) + case tools.V10.IsSupported(height): + return parse[*verifregv10.GetClaimsParams, *verifregv10.GetClaimsReturn](raw, rawReturn, true) + case tools.V11.IsSupported(height): return parse[*verifregv11.GetClaimsParams, *verifregv11.GetClaimsReturn](raw, rawReturn, true) + case tools.V12.IsSupported(height): + return parse[*verifregv12.GetClaimsParams, *verifregv12.GetClaimsReturn](raw, rawReturn, true) + case tools.V13.IsSupported(height): + return parse[*verifregv13.GetClaimsParams, *verifregv13.GetClaimsReturn](raw, rawReturn, true) + case tools.V14.IsSupported(height): + return parse[*verifregv14.GetClaimsParams, *verifregv14.GetClaimsReturn](raw, rawReturn, true) + case tools.V15.IsSupported(height): + return parse[*verifregv15.GetClaimsParams, *verifregv15.GetClaimsReturn](raw, rawReturn, true) } return nil, nil } func ExtendClaimTerms(height int64, raw, rawReturn []byte) (map[string]interface{}, error) { - switch height { - case 8: + switch { + case tools.V8.IsSupported(height): return parse[*verifregv8.ExtendClaimTermsParams, *verifregv8.ExtendClaimTermsReturn](raw, rawReturn, true) - case 11: + case tools.V9.IsSupported(height): + return parse[*verifregv9.ExtendClaimTermsParams, *verifregv9.ExtendClaimTermsReturn](raw, rawReturn, true) + case tools.V10.IsSupported(height): + return parse[*verifregv10.ExtendClaimTermsParams, *verifregv10.ExtendClaimTermsReturn](raw, rawReturn, true) + case tools.V11.IsSupported(height): return parse[*verifregv11.ExtendClaimTermsParams, *verifregv11.ExtendClaimTermsReturn](raw, rawReturn, true) + case tools.V12.IsSupported(height): + return parse[*verifregv12.ExtendClaimTermsParams, *verifregv12.ExtendClaimTermsReturn](raw, rawReturn, true) + case tools.V13.IsSupported(height): + return parse[*verifregv13.ExtendClaimTermsParams, *verifregv13.ExtendClaimTermsReturn](raw, rawReturn, true) + case tools.V14.IsSupported(height): + return parse[*verifregv14.ExtendClaimTermsParams, *verifregv14.ExtendClaimTermsReturn](raw, rawReturn, true) + case tools.V15.IsSupported(height): + return parse[*verifregv15.ExtendClaimTermsParams, *verifregv15.ExtendClaimTermsReturn](raw, rawReturn, true) } return nil, nil } func RemoveExpiredClaims(height int64, raw, rawReturn []byte) (map[string]interface{}, error) { - switch height { - case 8: + switch { + case tools.V8.IsSupported(height): return parse[*verifregv8.RemoveExpiredClaimsParams, *verifregv8.RemoveExpiredClaimsReturn](raw, rawReturn, true) - case 11: + case tools.V9.IsSupported(height): + return parse[*verifregv9.RemoveExpiredClaimsParams, *verifregv9.RemoveExpiredClaimsReturn](raw, rawReturn, true) + case tools.V10.IsSupported(height): + return parse[*verifregv10.RemoveExpiredClaimsParams, *verifregv10.RemoveExpiredClaimsReturn](raw, rawReturn, true) + case tools.V11.IsSupported(height): return parse[*verifregv11.RemoveExpiredClaimsParams, *verifregv11.RemoveExpiredClaimsReturn](raw, rawReturn, true) + case tools.V12.IsSupported(height): + return parse[*verifregv12.RemoveExpiredClaimsParams, *verifregv12.RemoveExpiredClaimsReturn](raw, rawReturn, true) + case tools.V13.IsSupported(height): + return parse[*verifregv13.RemoveExpiredClaimsParams, *verifregv13.RemoveExpiredClaimsReturn](raw, rawReturn, true) + case tools.V14.IsSupported(height): + return parse[*verifregv14.RemoveExpiredClaimsParams, *verifregv14.RemoveExpiredClaimsReturn](raw, rawReturn, true) + case tools.V15.IsSupported(height): + return parse[*verifregv15.RemoveExpiredClaimsParams, *verifregv15.RemoveExpiredClaimsReturn](raw, rawReturn, true) } return nil, nil } func VerifregUniversalReceiverHook(height int64, raw, rawReturn []byte) (map[string]interface{}, error) { - switch height { - case 8: + switch { + case tools.V8.IsSupported(height): return parse[*verifregv8.UniversalReceiverParams, *verifregv8.AllocationsResponse](raw, rawReturn, true) - case 11: + case tools.V9.IsSupported(height): + return parse[*verifregv9.UniversalReceiverParams, *verifregv9.AllocationsResponse](raw, rawReturn, true) + case tools.V10.IsSupported(height): + return parse[*verifregv10.UniversalReceiverParams, *verifregv10.AllocationsResponse](raw, rawReturn, true) + case tools.V11.IsSupported(height): return parse[*verifregv11.UniversalReceiverParams, *verifregv11.AllocationsResponse](raw, rawReturn, true) + case tools.V12.IsSupported(height): + return parse[*verifregv12.UniversalReceiverParams, *verifregv12.AllocationsResponse](raw, rawReturn, true) + case tools.V13.IsSupported(height): + return parse[*verifregv13.UniversalReceiverParams, *verifregv13.AllocationsResponse](raw, rawReturn, true) + case tools.V14.IsSupported(height): + return parse[*verifregv14.UniversalReceiverParams, *verifregv14.AllocationsResponse](raw, rawReturn, true) + case tools.V15.IsSupported(height): + return parse[*verifregv15.UniversalReceiverParams, *verifregv15.AllocationsResponse](raw, rawReturn, true) } return nil, nil } diff --git a/tools/version_mapping.go b/tools/version_mapping.go new file mode 100644 index 00000000..e236605b --- /dev/null +++ b/tools/version_mapping.go @@ -0,0 +1,47 @@ +package tools + +type version int64 + +var supportedVersions = []version{V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22} + +func (v version) IsSupported(height int64) bool { + return height <= int64(v.next()) +} + +func (v version) next() version { + for i, version := range supportedVersions { + if version == v { + if i == len(supportedVersions)-1 { + return v + } + return supportedVersions[i+1] + } + } + return v +} + +const ( + LatestVersion version = V22 + V1 version = 0 + V2 version = 100 + V3 version = 1000 + V4 version = 2000 + V5 version = 3000 + V6 version = 4000 + V7 version = 5000 + V8 version = 6000 + V9 version = 7000 + V10 version = 8000 + V11 version = 9000 + V12 version = 10000 + V13 version = 11000 + V14 version = 12000 + V15 version = 13000 + V16 version = 14000 + V17 version = 15000 + V18 version = 16000 + V19 version = 17000 + V20 version = 18000 + V21 version = 19000 + V22 version = 20000 +) From d47575a65522497a8228c7d2bcad369c60c8d99c Mon Sep 17 00:00:00 2001 From: Eric Mokaya Date: Wed, 22 Jan 2025 12:56:36 +0300 Subject: [PATCH 06/16] test: add testing architecture --- actors/account/account_test.go | 79 ++++++++ actors/datacap/allowance_test.go | 63 ++++++ actors/datacap/burn.go | 54 ++--- actors/datacap/burn_test.go | 25 +++ actors/datacap/datacap_test.go | 46 +++++ actors/datacap/granularity_test.go | 30 +++ actors/datacap/mint_test.go | 13 ++ actors/datacap/transfer_test.go | 12 ++ actors/eam/create_test.go | 60 ++++++ actors/eam/generic.go | 1 + actors/evm/evm_test.go | 122 +++++++++++ actors/init/init.go | 62 ------ actors/init/int_test.go | 81 ++++++++ actors/init/utils.go | 77 +++++++ actors/market/market_test.go | 191 ++++++++++++++++++ actors/miner/address_test.go | 96 +++++++++ actors/miner/balance_test.go | 22 ++ actors/miner/miner_test.go | 107 ++++++++++ actors/miner/sector_test.go | 86 ++++++++ actors/multisig/generic.go | 2 +- actors/multisig/multisig.go | 14 +- actors/multisig/multisig_test.go | 127 ++++++++++++ actors/multisig/types.go | 2 +- actors/multisig/values_test.go | 104 ++++++++++ actors/multisig/verifier_test.go | 12 ++ actors/paymentChannel/paymentChannel_test.go | 48 +++++ actors/power/power_test.go | 117 +++++++++++ actors/reward/reward_test.go | 58 ++++++ .../verifiedRegistry/verifiedRegistry_test.go | 126 ++++++++++++ tools/testutil.go | 158 +++++++++++++++ 30 files changed, 1897 insertions(+), 98 deletions(-) create mode 100644 actors/account/account_test.go create mode 100644 actors/datacap/allowance_test.go create mode 100644 actors/datacap/burn_test.go create mode 100644 actors/datacap/datacap_test.go create mode 100644 actors/datacap/granularity_test.go create mode 100644 actors/datacap/mint_test.go create mode 100644 actors/datacap/transfer_test.go create mode 100644 actors/eam/create_test.go create mode 100644 actors/evm/evm_test.go create mode 100644 actors/init/int_test.go create mode 100644 actors/init/utils.go create mode 100644 actors/market/market_test.go create mode 100644 actors/miner/address_test.go create mode 100644 actors/miner/balance_test.go create mode 100644 actors/miner/miner_test.go create mode 100644 actors/miner/sector_test.go create mode 100644 actors/multisig/multisig_test.go create mode 100644 actors/multisig/values_test.go create mode 100644 actors/multisig/verifier_test.go create mode 100644 actors/paymentChannel/paymentChannel_test.go create mode 100644 actors/power/power_test.go create mode 100644 actors/reward/reward_test.go create mode 100644 actors/verifiedRegistry/verifiedRegistry_test.go create mode 100644 tools/testutil.go diff --git a/actors/account/account_test.go b/actors/account/account_test.go new file mode 100644 index 00000000..f6c2d89c --- /dev/null +++ b/actors/account/account_test.go @@ -0,0 +1,79 @@ +package account_test + +import ( + "os" + "testing" + + "github.com/stretchr/testify/require" + "github.com/zondax/fil-parser/actors/account" + "github.com/zondax/fil-parser/tools" + rosettaFilecoinLib "github.com/zondax/rosetta-filecoin-lib" + + // typesV1 "github.com/zondax/fil-parser/parser/v1/types" + typesV2 "github.com/zondax/fil-parser/parser/v2/types" +) + +var lib *rosettaFilecoinLib.RosettaConstructionFilecoin + +func TestMain(m *testing.M) { + var err error + lib, err = tools.GetLib(tools.NodeUrl) + if err != nil { + panic(err) + } + os.Exit(m.Run()) +} + +func TestAuthenticateMessage(t *testing.T) { + tests := []struct { + name string + version string + url string + height int64 + expected map[string]any + }{} + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.height, tt.version) + require.NoError(t, err) + + for _, trace := range computeState.Trace { + if trace.Msg == nil { + continue + } + result, err := account.AuthenticateMessage(tt.height, trace.Msg.Params, trace.MsgRct.Return) + require.NoError(t, err) + require.True(t, tools.CompareResult(result, tt.expected)) + } + + }) + } +} + +func TestPubkeyAddress(t *testing.T) { + tests := []struct { + name string + version string + url string + height int64 + expected map[string]any + }{} + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.height, tt.version) + require.NoError(t, err) + + for _, trace := range computeState.Trace { + if trace.Msg == nil { + continue + } + result, err := account.PubkeyAddress(trace.Msg.Params, trace.MsgRct.Return) + require.NoError(t, err) + require.True(t, tools.CompareResult(result, tt.expected)) + } + + }) + } +} diff --git a/actors/datacap/allowance_test.go b/actors/datacap/allowance_test.go new file mode 100644 index 00000000..ae0b8248 --- /dev/null +++ b/actors/datacap/allowance_test.go @@ -0,0 +1,63 @@ +package datacap_test + +import ( + "testing" + + "github.com/stretchr/testify/require" + "github.com/zondax/fil-parser/actors/datacap" + "github.com/zondax/fil-parser/tools" + + typesV2 "github.com/zondax/fil-parser/parser/v2/types" +) + +type testFn func(height int64, raw, rawReturn []byte) (map[string]interface{}, error) + +type test struct { + name string + version string + url string + height int64 + expected map[string]any +} + +func TestIncreaseAllowance(t *testing.T) { + tests := []test{} + + runTest(t, datacap.IncreaseAllowance, tests) +} + +func TestDecreaseAllowance(t *testing.T) { + tests := []test{} + + runTest(t, datacap.DecreaseAllowance, tests) +} + +func TestRevokeAllowance(t *testing.T) { + tests := []test{} + + runTest(t, datacap.RevokeAllowance, tests) +} + +func TestGetAllowance(t *testing.T) { + tests := []test{} + + runTest(t, datacap.GetAllowance, tests) +} + +func runTest(t *testing.T, fn testFn, tests []test) { + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.height, tt.version) + require.NoError(t, err) + + for _, trace := range computeState.Trace { + if trace.Msg == nil { + continue + } + result, err := fn(tt.height, trace.Msg.Params, trace.MsgRct.Return) + require.NoError(t, err) + require.True(t, tools.CompareResult(result, tt.expected)) + } + }) + } +} diff --git a/actors/datacap/burn.go b/actors/datacap/burn.go index ebde2c3e..736aa40e 100644 --- a/actors/datacap/burn.go +++ b/actors/datacap/burn.go @@ -14,67 +14,67 @@ import ( "github.com/zondax/fil-parser/tools" ) -func BurnExported(height uint64, raw, rawReturn []byte) (map[string]interface{}, error) { +func BurnExported(height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(int64(height)): + case tools.V8.IsSupported(height): return parse[*datacapv8.BurnParams, *datacapv8.BurnReturn](raw, rawReturn, true) - case tools.V9.IsSupported(int64(height)): + case tools.V9.IsSupported(height): return parse[*datacapv9.BurnParams, *datacapv9.BurnReturn](raw, rawReturn, true) - case tools.V10.IsSupported(int64(height)): + case tools.V10.IsSupported(height): return parse[*datacapv10.BurnParams, *datacapv10.BurnReturn](raw, rawReturn, true) - case tools.V11.IsSupported(int64(height)): + case tools.V11.IsSupported(height): return parse[*datacapv11.BurnParams, *datacapv11.BurnReturn](raw, rawReturn, true) - case tools.V12.IsSupported(int64(height)): + case tools.V12.IsSupported(height): return parse[*datacapv12.BurnParams, *datacapv12.BurnReturn](raw, rawReturn, true) - case tools.V13.IsSupported(int64(height)): + case tools.V13.IsSupported(height): return parse[*datacapv13.BurnParams, *datacapv13.BurnReturn](raw, rawReturn, true) - case tools.V14.IsSupported(int64(height)): + case tools.V14.IsSupported(height): return parse[*datacapv14.BurnParams, *datacapv14.BurnReturn](raw, rawReturn, true) - case tools.V15.IsSupported(int64(height)): + case tools.V15.IsSupported(height): return parse[*datacapv15.BurnParams, *datacapv15.BurnReturn](raw, rawReturn, true) } return nil, fmt.Errorf("not supported") } -func BurnFromExported(height uint64, raw, rawReturn []byte) (map[string]interface{}, error) { +func BurnFromExported(height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(int64(height)): + case tools.V8.IsSupported(height): return parse[*datacapv8.BurnFromParams, *datacapv8.BurnFromReturn](raw, rawReturn, true) - case tools.V9.IsSupported(int64(height)): + case tools.V9.IsSupported(height): return parse[*datacapv9.BurnFromParams, *datacapv9.BurnFromReturn](raw, rawReturn, true) - case tools.V10.IsSupported(int64(height)): + case tools.V10.IsSupported(height): return parse[*datacapv10.BurnFromParams, *datacapv10.BurnFromReturn](raw, rawReturn, true) - case tools.V11.IsSupported(int64(height)): + case tools.V11.IsSupported(height): return parse[*datacapv11.BurnFromParams, *datacapv11.BurnFromReturn](raw, rawReturn, true) - case tools.V12.IsSupported(int64(height)): + case tools.V12.IsSupported(height): return parse[*datacapv12.BurnFromParams, *datacapv12.BurnFromReturn](raw, rawReturn, true) - case tools.V13.IsSupported(int64(height)): + case tools.V13.IsSupported(height): return parse[*datacapv13.BurnFromParams, *datacapv13.BurnFromReturn](raw, rawReturn, true) - case tools.V14.IsSupported(int64(height)): + case tools.V14.IsSupported(height): return parse[*datacapv14.BurnFromParams, *datacapv14.BurnFromReturn](raw, rawReturn, true) - case tools.V15.IsSupported(int64(height)): + case tools.V15.IsSupported(height): return parse[*datacapv15.BurnFromParams, *datacapv15.BurnFromReturn](raw, rawReturn, true) } return nil, fmt.Errorf("not supported") } -func DestroyExported(height uint64, raw, rawReturn []byte) (map[string]interface{}, error) { +func DestroyExported(height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(int64(height)): + case tools.V8.IsSupported(height): return parse[*datacapv8.DestroyParams, *datacapv8.BurnReturn](raw, rawReturn, true) - case tools.V9.IsSupported(int64(height)): + case tools.V9.IsSupported(height): return parse[*datacapv9.DestroyParams, *datacapv9.BurnReturn](raw, rawReturn, true) - case tools.V10.IsSupported(int64(height)): + case tools.V10.IsSupported(height): return parse[*datacapv10.DestroyParams, *datacapv10.BurnReturn](raw, rawReturn, true) - case tools.V11.IsSupported(int64(height)): + case tools.V11.IsSupported(height): return parse[*datacapv11.DestroyParams, *datacapv11.BurnReturn](raw, rawReturn, true) - case tools.V12.IsSupported(int64(height)): + case tools.V12.IsSupported(height): return parse[*datacapv12.DestroyParams, *datacapv12.BurnReturn](raw, rawReturn, true) - case tools.V13.IsSupported(int64(height)): + case tools.V13.IsSupported(height): return parse[*datacapv13.DestroyParams, *datacapv13.BurnReturn](raw, rawReturn, true) - case tools.V14.IsSupported(int64(height)): + case tools.V14.IsSupported(height): return parse[*datacapv14.DestroyParams, *datacapv14.BurnReturn](raw, rawReturn, true) - case tools.V15.IsSupported(int64(height)): + case tools.V15.IsSupported(height): return parse[*datacapv15.DestroyParams, *datacapv15.BurnReturn](raw, rawReturn, true) } return nil, fmt.Errorf("not supported") diff --git a/actors/datacap/burn_test.go b/actors/datacap/burn_test.go new file mode 100644 index 00000000..78356020 --- /dev/null +++ b/actors/datacap/burn_test.go @@ -0,0 +1,25 @@ +package datacap_test + +import ( + "testing" + + "github.com/zondax/fil-parser/actors/datacap" +) + +func TestBurnExported(t *testing.T) { + tests := []test{} + + runTest(t, datacap.BurnExported, tests) +} + +func TestBurnFromExported(t *testing.T) { + tests := []test{} + + runTest(t, datacap.BurnFromExported, tests) +} + +func TestDestroyExported(t *testing.T) { + tests := []test{} + + runTest(t, datacap.DestroyExported, tests) +} diff --git a/actors/datacap/datacap_test.go b/actors/datacap/datacap_test.go new file mode 100644 index 00000000..3f5686db --- /dev/null +++ b/actors/datacap/datacap_test.go @@ -0,0 +1,46 @@ +package datacap_test + +import ( + "testing" + + "github.com/stretchr/testify/require" + "github.com/zondax/fil-parser/actors/datacap" + typesV2 "github.com/zondax/fil-parser/parser/v2/types" + "github.com/zondax/fil-parser/tools" +) + +func TestNameExported(t *testing.T) { + tests := []test{} + + runDatacapTest(t, datacap.NameExported, tests) +} + +func TestSymbolExported(t *testing.T) { + tests := []test{} + + runDatacapTest(t, datacap.SymbolExported, tests) +} + +func TestTotalSupplyExported(t *testing.T) { + tests := []test{} + + runDatacapTest(t, datacap.TotalSupplyExported, tests) +} + +func runDatacapTest(t *testing.T, fn func(rawReturn []byte) (map[string]interface{}, error), tests []test) { + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.height, tt.version) + require.NoError(t, err) + + for _, trace := range computeState.Trace { + if trace.Msg == nil { + continue + } + result, err := fn(trace.MsgRct.Return) + require.NoError(t, err) + require.True(t, tools.CompareResult(result, tt.expected)) + } + }) + } +} diff --git a/actors/datacap/granularity_test.go b/actors/datacap/granularity_test.go new file mode 100644 index 00000000..0af6f080 --- /dev/null +++ b/actors/datacap/granularity_test.go @@ -0,0 +1,30 @@ +package datacap_test + +import ( + "testing" + + "github.com/stretchr/testify/require" + "github.com/zondax/fil-parser/actors/datacap" + typesV2 "github.com/zondax/fil-parser/parser/v2/types" + "github.com/zondax/fil-parser/tools" +) + +func TestGranularityExported(t *testing.T) { + tests := []test{} + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.height, tt.version) + require.NoError(t, err) + + for _, trace := range computeState.Trace { + if trace.Msg == nil { + continue + } + result, err := datacap.GranularityExported(tt.height, trace.MsgRct.Return) + require.NoError(t, err) + require.True(t, tools.CompareResult(result, tt.expected)) + } + }) + } +} diff --git a/actors/datacap/mint_test.go b/actors/datacap/mint_test.go new file mode 100644 index 00000000..7fdf0bff --- /dev/null +++ b/actors/datacap/mint_test.go @@ -0,0 +1,13 @@ +package datacap_test + +import ( + "testing" + + "github.com/zondax/fil-parser/actors/datacap" +) + +func TestMintExported(t *testing.T) { + tests := []test{} + runTest(t, datacap.MintExported, tests) + +} diff --git a/actors/datacap/transfer_test.go b/actors/datacap/transfer_test.go new file mode 100644 index 00000000..89f50701 --- /dev/null +++ b/actors/datacap/transfer_test.go @@ -0,0 +1,12 @@ +package datacap_test + +import ( + "testing" + + "github.com/zondax/fil-parser/actors/datacap" +) + +func TestTransferExported(t *testing.T) { + tests := []test{} + runTest(t, datacap.TransferExported, tests) +} diff --git a/actors/eam/create_test.go b/actors/eam/create_test.go new file mode 100644 index 00000000..983ef272 --- /dev/null +++ b/actors/eam/create_test.go @@ -0,0 +1,60 @@ +package eam_test + +import ( + "testing" + + "github.com/ipfs/go-cid" + "github.com/stretchr/testify/require" + "github.com/zondax/fil-parser/actors/eam" + typesV2 "github.com/zondax/fil-parser/parser/v2/types" + "github.com/zondax/fil-parser/tools" + "github.com/zondax/fil-parser/types" +) + +type testFn func(height int64, raw, rawReturn []byte, msgCid cid.Cid) (map[string]interface{}, *types.AddressInfo, error) + +type test struct { + name string + version string + url string + height int64 + expected map[string]any + addr *types.AddressInfo +} + +func TestParseCreateExternal(t *testing.T) { + tests := []test{} + + runTest(t, eam.ParseCreateExternal, tests) +} + +func TestParseCreate(t *testing.T) { + tests := []test{} + + runTest(t, eam.ParseCreate, tests) +} + +func TestParseCreate2(t *testing.T) { + tests := []test{} + + runTest(t, eam.ParseCreate2, tests) +} + +func runTest(t *testing.T, fn testFn, tests []test) { + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.height, tt.version) + require.NoError(t, err) + + for _, trace := range computeState.Trace { + if trace.Msg == nil { + continue + } + result, addrInfo, err := fn(tt.height, trace.Msg.Params, trace.MsgRct.Return, trace.Msg.Cid()) + require.NoError(t, err) + require.True(t, tools.CompareResult(result, tt.expected)) + require.Equal(t, addrInfo, tt.addr) + } + }) + } +} diff --git a/actors/eam/generic.go b/actors/eam/generic.go index 5aef53a9..a256222b 100644 --- a/actors/eam/generic.go +++ b/actors/eam/generic.go @@ -51,6 +51,7 @@ func parseCreate[T createReturn](rawParams, rawReturn []byte, msgCid cid.Cid, is if err != nil { return metadata, nil, err } + metadata[parser.ParamsKey] = params } createReturn, err := parseEamReturn[T](rawReturn) diff --git a/actors/evm/evm_test.go b/actors/evm/evm_test.go new file mode 100644 index 00000000..1490a502 --- /dev/null +++ b/actors/evm/evm_test.go @@ -0,0 +1,122 @@ +package evm_test + +import ( + "testing" + + "github.com/stretchr/testify/require" + "github.com/zondax/fil-parser/actors/evm" + "github.com/zondax/fil-parser/tools" + + typesV2 "github.com/zondax/fil-parser/parser/v2/types" +) + +type testFn func(height int64, raw []byte) (map[string]interface{}, error) + +type test struct { + name string + version string + url string + height int64 + expected map[string]any +} + +func TestResurrect(t *testing.T) { + tests := []test{} + + runTest(t, evm.Resurrect, tests) +} + +func TestGetByteCode(t *testing.T) { + tests := []test{} + + runTest(t, evm.GetByteCode, tests) +} + +func TestGetByteCodeHash(t *testing.T) { + tests := []test{} + + runTest(t, evm.GetByteCodeHash, tests) +} + +func TestEVMConstructor(t *testing.T) { + tests := []test{} + + runTest(t, evm.EVMConstructor, tests) +} + +func TestGetStorageAt(t *testing.T) { + tests := []test{} + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.height, tt.version) + require.NoError(t, err) + + for _, trace := range computeState.Trace { + if trace.Msg == nil { + continue + } + result, err := evm.GetStorageAt(tt.height, trace.Msg.Params, trace.MsgRct.Return) + require.NoError(t, err) + require.True(t, tools.CompareResult(result, tt.expected)) + } + }) + } +} + +func TestInvokeContract(t *testing.T) { + tests := []test{} + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.height, tt.version) + require.NoError(t, err) + + for _, trace := range computeState.Trace { + if trace.Msg == nil { + continue + } + result, err := evm.InvokeContract(trace.Msg.Params, trace.MsgRct.Return) + require.NoError(t, err) + require.True(t, tools.CompareResult(result, tt.expected)) + } + }) + } +} + +func TestInvokeContractDelegate(t *testing.T) { + tests := []test{} + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.height, tt.version) + require.NoError(t, err) + + for _, trace := range computeState.Trace { + if trace.Msg == nil { + continue + } + result, err := evm.InvokeContractDelegate(tt.height, trace.Msg.Params, trace.MsgRct.Return) + require.NoError(t, err) + require.True(t, tools.CompareResult(result, tt.expected)) + } + }) + } +} + +func runTest(t *testing.T, fn testFn, tests []test) { + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.height, tt.version) + require.NoError(t, err) + + for _, trace := range computeState.Trace { + if trace.Msg == nil { + continue + } + result, err := fn(tt.height, trace.Msg.Params) + require.NoError(t, err) + require.True(t, tools.CompareResult(result, tt.expected)) + } + }) + } +} diff --git a/actors/init/init.go b/actors/init/init.go index 7c62d157..8e5c0d8c 100644 --- a/actors/init/init.go +++ b/actors/init/init.go @@ -1,10 +1,8 @@ package init import ( - "encoding/base64" "fmt" - "github.com/filecoin-project/go-address" builtinInitv10 "github.com/filecoin-project/go-state-types/builtin/v10/init" builtinInitv11 "github.com/filecoin-project/go-state-types/builtin/v11/init" builtinInitv12 "github.com/filecoin-project/go-state-types/builtin/v12/init" @@ -13,72 +11,12 @@ import ( builtinInitv15 "github.com/filecoin-project/go-state-types/builtin/v15/init" builtinInitv8 "github.com/filecoin-project/go-state-types/builtin/v8/init" builtinInitv9 "github.com/filecoin-project/go-state-types/builtin/v9/init" - "github.com/ipfs/go-cid" "github.com/zondax/fil-parser/parser" "github.com/zondax/fil-parser/tools" "github.com/zondax/fil-parser/types" ) -func execParams(params constructorParams) parser.ExecParams { - setParams := func(codeCid cid.Cid, constructorParams []byte) parser.ExecParams { - return parser.ExecParams{ - CodeCid: codeCid.String(), - ConstructorParams: base64.StdEncoding.EncodeToString(constructorParams), - } - } - switch v := params.(type) { - case *builtinInitv15.ExecParams: - return setParams(v.CodeCID, v.ConstructorParams) - case *builtinInitv14.ExecParams: - return setParams(v.CodeCID, v.ConstructorParams) - case *builtinInitv13.ExecParams: - return setParams(v.CodeCID, v.ConstructorParams) - case *builtinInitv12.ExecParams: - return setParams(v.CodeCID, v.ConstructorParams) - case *builtinInitv11.ExecParams: - return setParams(v.CodeCID, v.ConstructorParams) - case *builtinInitv10.ExecParams: - return setParams(v.CodeCID, v.ConstructorParams) - case *builtinInitv9.ExecParams: - return setParams(v.CodeCID, v.ConstructorParams) - case *builtinInitv8.ExecParams: - return setParams(v.CodeCID, v.ConstructorParams) - } - return parser.ExecParams{} -} - -func returnParams(msg *parser.LotusMessage, actorCID string, params execReturn) *types.AddressInfo { - setReturn := func(idAddress, robustAddress address.Address) *types.AddressInfo { - return &types.AddressInfo{ - Short: idAddress.String(), - Robust: robustAddress.String(), - ActorCid: actorCID, - CreationTxCid: msg.Cid.String(), - } - } - switch v := params.(type) { - case *builtinInitv15.ExecReturn: - return setReturn(v.IDAddress, v.RobustAddress) - case *builtinInitv14.ExecReturn: - return setReturn(v.IDAddress, v.RobustAddress) - case *builtinInitv13.ExecReturn: - return setReturn(v.IDAddress, v.RobustAddress) - case *builtinInitv12.ExecReturn: - return setReturn(v.IDAddress, v.RobustAddress) - case *builtinInitv11.ExecReturn: - return setReturn(v.IDAddress, v.RobustAddress) - case *builtinInitv10.ExecReturn: - return setReturn(v.IDAddress, v.RobustAddress) - case *builtinInitv9.ExecReturn: - return setReturn(v.IDAddress, v.RobustAddress) - case *builtinInitv8.ExecReturn: - return setReturn(v.IDAddress, v.RobustAddress) - } - return &types.AddressInfo{} - -} - func InitConstructor(height int64, raw []byte) (map[string]interface{}, error) { switch { case tools.V15.IsSupported(height): diff --git a/actors/init/int_test.go b/actors/init/int_test.go new file mode 100644 index 00000000..648972ff --- /dev/null +++ b/actors/init/int_test.go @@ -0,0 +1,81 @@ +package init_test + +import ( + "testing" + + "github.com/stretchr/testify/require" + initActor "github.com/zondax/fil-parser/actors/init" + "github.com/zondax/fil-parser/parser" + "github.com/zondax/fil-parser/tools" + "github.com/zondax/fil-parser/types" + + typesV2 "github.com/zondax/fil-parser/parser/v2/types" +) + +type testFn func(height int64, msg *parser.LotusMessage, raw []byte) (map[string]interface{}, *types.AddressInfo, error) + +type test struct { + name string + version string + url string + height int64 + expected map[string]any + address *types.AddressInfo +} + +func TestParseExec(t *testing.T) { + tests := []test{} + + runTest(t, initActor.ParseExec, tests) +} + +func TestParseExec4(t *testing.T) { + tests := []test{} + + runTest(t, initActor.ParseExec4, tests) +} + +func TestInitConstructor(t *testing.T) { + tests := []test{} + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.height, tt.version) + require.NoError(t, err) + + for _, trace := range computeState.Trace { + if trace.Msg == nil { + continue + } + + result, err := initActor.InitConstructor(tt.height, trace.Msg.Params) + require.NoError(t, err) + require.True(t, tools.CompareResult(result, tt.expected)) + } + }) + } + +} + +func runTest(t *testing.T, fn testFn, tests []test) { + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.height, tt.version) + require.NoError(t, err) + + for _, trace := range computeState.Trace { + if trace.Msg == nil { + continue + } + lotusMsg := &parser.LotusMessage{ + To: trace.Msg.To, + From: trace.Msg.From, + Method: trace.Msg.Method, + } + result, address, err := fn(tt.height, lotusMsg, trace.Msg.Params) + require.NoError(t, err) + require.True(t, tools.CompareResult(result, tt.expected)) + require.Equal(t, address, tt.address) + } + }) + } +} diff --git a/actors/init/utils.go b/actors/init/utils.go new file mode 100644 index 00000000..7c4f3bca --- /dev/null +++ b/actors/init/utils.go @@ -0,0 +1,77 @@ +package init + +import ( + "encoding/base64" + + "github.com/filecoin-project/go-address" + builtinInitv10 "github.com/filecoin-project/go-state-types/builtin/v10/init" + builtinInitv11 "github.com/filecoin-project/go-state-types/builtin/v11/init" + builtinInitv12 "github.com/filecoin-project/go-state-types/builtin/v12/init" + builtinInitv13 "github.com/filecoin-project/go-state-types/builtin/v13/init" + builtinInitv14 "github.com/filecoin-project/go-state-types/builtin/v14/init" + builtinInitv15 "github.com/filecoin-project/go-state-types/builtin/v15/init" + builtinInitv8 "github.com/filecoin-project/go-state-types/builtin/v8/init" + builtinInitv9 "github.com/filecoin-project/go-state-types/builtin/v9/init" + "github.com/ipfs/go-cid" + "github.com/zondax/fil-parser/parser" + "github.com/zondax/fil-parser/types" +) + +func execParams(params constructorParams) parser.ExecParams { + setParams := func(codeCid cid.Cid, constructorParams []byte) parser.ExecParams { + return parser.ExecParams{ + CodeCid: codeCid.String(), + ConstructorParams: base64.StdEncoding.EncodeToString(constructorParams), + } + } + switch v := params.(type) { + case *builtinInitv15.ExecParams: + return setParams(v.CodeCID, v.ConstructorParams) + case *builtinInitv14.ExecParams: + return setParams(v.CodeCID, v.ConstructorParams) + case *builtinInitv13.ExecParams: + return setParams(v.CodeCID, v.ConstructorParams) + case *builtinInitv12.ExecParams: + return setParams(v.CodeCID, v.ConstructorParams) + case *builtinInitv11.ExecParams: + return setParams(v.CodeCID, v.ConstructorParams) + case *builtinInitv10.ExecParams: + return setParams(v.CodeCID, v.ConstructorParams) + case *builtinInitv9.ExecParams: + return setParams(v.CodeCID, v.ConstructorParams) + case *builtinInitv8.ExecParams: + return setParams(v.CodeCID, v.ConstructorParams) + } + return parser.ExecParams{} +} + +func returnParams(msg *parser.LotusMessage, actorCID string, params execReturn) *types.AddressInfo { + setReturn := func(idAddress, robustAddress address.Address) *types.AddressInfo { + return &types.AddressInfo{ + Short: idAddress.String(), + Robust: robustAddress.String(), + ActorCid: actorCID, + CreationTxCid: msg.Cid.String(), + } + } + switch v := params.(type) { + case *builtinInitv15.ExecReturn: + return setReturn(v.IDAddress, v.RobustAddress) + case *builtinInitv14.ExecReturn: + return setReturn(v.IDAddress, v.RobustAddress) + case *builtinInitv13.ExecReturn: + return setReturn(v.IDAddress, v.RobustAddress) + case *builtinInitv12.ExecReturn: + return setReturn(v.IDAddress, v.RobustAddress) + case *builtinInitv11.ExecReturn: + return setReturn(v.IDAddress, v.RobustAddress) + case *builtinInitv10.ExecReturn: + return setReturn(v.IDAddress, v.RobustAddress) + case *builtinInitv9.ExecReturn: + return setReturn(v.IDAddress, v.RobustAddress) + case *builtinInitv8.ExecReturn: + return setReturn(v.IDAddress, v.RobustAddress) + } + return &types.AddressInfo{} + +} diff --git a/actors/market/market_test.go b/actors/market/market_test.go new file mode 100644 index 00000000..87f22209 --- /dev/null +++ b/actors/market/market_test.go @@ -0,0 +1,191 @@ +package market_test + +import ( + "testing" + + "github.com/stretchr/testify/require" + "github.com/zondax/fil-parser/actors/market" + "github.com/zondax/fil-parser/tools" + + typesV2 "github.com/zondax/fil-parser/parser/v2/types" +) + +type testFn func(height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) + +type test struct { + name string + version string + url string + height int64 + expected map[string]any +} + +func TestPublishStorageDeals(t *testing.T) { + tests := []test{} + + runTest(t, market.PublishStorageDealsParams, tests) +} + +func TestVerifyDealsForActivation(t *testing.T) { + tests := []test{} + runTest(t, market.VerifyDealsForActivationParams, tests) +} + +func TestActivateDeals(t *testing.T) { + tests := []test{} + runTest(t, market.ActivateDealsParams, tests) +} + +func TestComputeDataCommitment(t *testing.T) { + tests := []test{} + runTest(t, market.ComputeDataCommitmentParams, tests) +} + +func TestGetBalance(t *testing.T) { + tests := []test{} + runTest(t, market.GetBalanceParams, tests) +} + +func TestGetDealDataCommitment(t *testing.T) { + tests := []test{} + runTest(t, market.GetDealDataCommitmentParams, tests) +} + +func TestGetDealClient(t *testing.T) { + tests := []test{} + runTest(t, market.GetDealClientParams, tests) +} + +func TestGetDealProvider(t *testing.T) { + tests := []test{} + runTest(t, market.GetDealProviderParams, tests) +} + +func TestGetDealLabel(t *testing.T) { + tests := []test{} + runTest(t, market.GetDealLabelParams, tests) +} + +func TestGetDealTerm(t *testing.T) { + tests := []test{} + runTest(t, market.GetDealTermParams, tests) +} + +func TestGetDealTotalPrice(t *testing.T) { + tests := []test{} + runTest(t, market.GetDealTotalPriceParams, tests) +} + +func TestGetDealClientCollateral(t *testing.T) { + tests := []test{} + runTest(t, market.GetDealClientCollateralParams, tests) +} + +func TestGetDealProviderCollateral(t *testing.T) { + tests := []test{} + runTest(t, market.GetDealProviderCollateralParams, tests) +} + +func TestGetDealVerified(t *testing.T) { + tests := []test{} + runTest(t, market.GetDealVerifiedParams, tests) +} + +func TestGetDealActivation(t *testing.T) { + tests := []test{} + runTest(t, market.GetDealActivationParams, tests) +} + +func TestDealProviderCollateral(t *testing.T) { + tests := []test{} + runTest(t, market.GetDealProviderCollateralParams, tests) +} + +func TestGetDealVerifiedParams(t *testing.T) { + tests := []test{} + runTest(t, market.GetDealVerifiedParams, tests) +} + +func TestGetDealActivationParams(t *testing.T) { + tests := []test{} + runTest(t, market.GetDealActivationParams, tests) +} + +func TestOnMinerSectorsTerminate(t *testing.T) { + tests := []test{} + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.height, tt.version) + require.NoError(t, err) + + for _, trace := range computeState.Trace { + if trace.Msg == nil { + continue + } + + result, err := market.OnMinerSectorsTerminateParams(tt.height, trace.Msg.Params) + require.NoError(t, err) + require.True(t, tools.CompareResult(result, tt.expected)) + } + }) + } +} + +func TestParseAddBalance(t *testing.T) { + tests := []test{} + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.height, tt.version) + require.NoError(t, err) + + for _, trace := range computeState.Trace { + if trace.Msg == nil { + continue + } + + result, err := market.ParseAddBalance(tt.height, trace.Msg.Params) + require.NoError(t, err) + require.True(t, tools.CompareResult(result, tt.expected)) + } + }) + } +} + +func TestParseWithdrawBalance(t *testing.T) { + tests := []test{} + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.height, tt.version) + require.NoError(t, err) + + for _, trace := range computeState.Trace { + if trace.Msg == nil { + continue + } + + result, err := market.ParseWithdrawBalance(tt.height, trace.Msg.Params) + require.NoError(t, err) + require.True(t, tools.CompareResult(result, tt.expected)) + } + }) + } +} + +func runTest(t *testing.T, fn testFn, tests []test) { + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.height, tt.version) + require.NoError(t, err) + + for _, trace := range computeState.Trace { + if trace.Msg == nil { + continue + } + + result, err := fn(tt.height, trace.Msg.Params, trace.MsgRct.Return) + require.NoError(t, err) + require.True(t, tools.CompareResult(result, tt.expected)) + } + }) + } +} diff --git a/actors/miner/address_test.go b/actors/miner/address_test.go new file mode 100644 index 00000000..c7a1c00d --- /dev/null +++ b/actors/miner/address_test.go @@ -0,0 +1,96 @@ +package miner_test + +import ( + "testing" + + "github.com/stretchr/testify/require" + "github.com/zondax/fil-parser/actors/miner" + typesV2 "github.com/zondax/fil-parser/parser/v2/types" + "github.com/zondax/fil-parser/tools" +) + +type testFn func(height int64, rawReturn []byte) (map[string]interface{}, error) + +type test struct { + name string + version string + url string + height int64 + expected map[string]any +} + +func TestChangeMultiaddrs(t *testing.T) { + tests := []test{} + runTest(t, miner.ChangeMultiaddrs, tests) +} + +func TestChangePeerID(t *testing.T) { + tests := []test{} + runTest(t, miner.ChangePeerID, tests) +} + +func TestChangeWorkerAddress(t *testing.T) { + tests := []test{} + runTest(t, miner.ChangeWorkerAddress, tests) +} + +func TestChangeOwnerAddress(t *testing.T) { + tests := []test{} + runTest(t, miner.ChangeOwnerAddress, tests) +} + +func TestGetOwner(t *testing.T) { + tests := []test{} + runTest(t, miner.GetOwner, tests) +} + +func TestGetPeerID(t *testing.T) { + tests := []test{} + runTest(t, miner.GetPeerID, tests) +} + +func TestGetMultiaddrs(t *testing.T) { + tests := []test{} + runTest(t, miner.GetMultiaddrs, tests) +} + +func TestIsControllingAddressExported(t *testing.T) { + tests := []test{} + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.height, tt.version) + require.NoError(t, err) + + for _, trace := range computeState.Trace { + if trace.Msg == nil { + continue + } + + result, err := miner.IsControllingAddressExported(tt.height, trace.Msg.Params, trace.MsgRct.Return) + require.NoError(t, err) + require.True(t, tools.CompareResult(result, tt.expected)) + + } + }) + } +} + +func runTest(t *testing.T, fn testFn, tests []test) { + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.height, tt.version) + require.NoError(t, err) + + for _, trace := range computeState.Trace { + if trace.Msg == nil { + continue + } + + result, err := fn(tt.height, trace.MsgRct.Return) + require.NoError(t, err) + require.True(t, tools.CompareResult(result, tt.expected)) + + } + }) + } +} diff --git a/actors/miner/balance_test.go b/actors/miner/balance_test.go new file mode 100644 index 00000000..81efdd9a --- /dev/null +++ b/actors/miner/balance_test.go @@ -0,0 +1,22 @@ +package miner_test + +import ( + "testing" + + "github.com/zondax/fil-parser/actors/miner" +) + +func TestGetAvailableBalance(t *testing.T) { + tests := []test{} + runTest(t, miner.GetAvailableBalance, tests) +} + +func TestGetVestingFunds(t *testing.T) { + tests := []test{} + runTest(t, miner.GetVestingFunds, tests) +} + +func TestParseWithdrawBalance(t *testing.T) { + tests := []test{} + runTest(t, miner.ParseWithdrawBalance, tests) +} diff --git a/actors/miner/miner_test.go b/actors/miner/miner_test.go new file mode 100644 index 00000000..19eb69ee --- /dev/null +++ b/actors/miner/miner_test.go @@ -0,0 +1,107 @@ +package miner_test + +import ( + "testing" + + "github.com/stretchr/testify/require" + "github.com/zondax/fil-parser/actors/miner" + typesV2 "github.com/zondax/fil-parser/parser/v2/types" + "github.com/zondax/fil-parser/tools" +) + +func TestDeclareFaults(t *testing.T) { + tests := []test{} + runTest(t, miner.DeclareFaults, tests) +} + +func TestDeclareFaultsRecovered(t *testing.T) { + tests := []test{} + runTest(t, miner.DeclareFaultsRecovered, tests) +} + +func TestProveReplicaUpdates(t *testing.T) { + tests := []test{} + runTest(t, miner.ProveReplicaUpdates, tests) +} + +func TestPreCommitSectorBatch2(t *testing.T) { + tests := []test{} + runTest(t, miner.PreCommitSectorBatch2, tests) +} + +func TestProveCommitAggregate(t *testing.T) { + tests := []test{} + runTest(t, miner.ProveCommitAggregate, tests) +} + +func TestDisputeWindowedPoSt(t *testing.T) { + tests := []test{} + runTest(t, miner.DisputeWindowedPoSt, tests) +} + +func TestReportConsensusFault(t *testing.T) { + tests := []test{} + runTest(t, miner.ReportConsensusFault, tests) +} + +func TestChangeBeneficiary(t *testing.T) { + tests := []test{} + runTest(t, miner.ChangeBeneficiary, tests) +} + +func TestMinerConstructor(t *testing.T) { + tests := []test{} + runTest(t, miner.MinerConstructor, tests) +} + +func TestApplyRewards(t *testing.T) { + tests := []test{} + runTest(t, miner.ApplyRewards, tests) +} + +func TestOnDeferredCronEvent(t *testing.T) { + tests := []test{} + runTest(t, miner.OnDeferredCronEvent, tests) +} + +func TestTerminateSectors(t *testing.T) { + tests := []test{} + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.height, tt.version) + require.NoError(t, err) + + for _, trace := range computeState.Trace { + if trace.Msg == nil { + continue + } + + result, err := miner.TerminateSectors(tt.height, trace.Msg.Params, trace.MsgRct.Return) + require.NoError(t, err) + require.True(t, tools.CompareResult(result, tt.expected)) + + } + }) + } +} + +func TestProveReplicaUpdates2(t *testing.T) { + tests := []test{} + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.height, tt.version) + require.NoError(t, err) + + for _, trace := range computeState.Trace { + if trace.Msg == nil { + continue + } + + result, err := miner.ProveReplicaUpdates2(tt.height, trace.Msg.Params, trace.MsgRct.Return) + require.NoError(t, err) + require.True(t, tools.CompareResult(result, tt.expected)) + + } + }) + } +} diff --git a/actors/miner/sector_test.go b/actors/miner/sector_test.go new file mode 100644 index 00000000..8be0c9cb --- /dev/null +++ b/actors/miner/sector_test.go @@ -0,0 +1,86 @@ +package miner_test + +import ( + "testing" + + "github.com/stretchr/testify/require" + "github.com/zondax/fil-parser/actors/miner" + typesV2 "github.com/zondax/fil-parser/parser/v2/types" + "github.com/zondax/fil-parser/tools" +) + +func TestExtendSectorExpiration2(t *testing.T) { + tests := []test{} + runTest(t, miner.ExtendSectorExpiration2, tests) +} + +func TestPreCommitSector(t *testing.T) { + tests := []test{} + runTest(t, miner.PreCommitSector, tests) +} + +func TestProveCommitSector(t *testing.T) { + tests := []test{} + runTest(t, miner.ProveCommitSector, tests) +} + +func TestSubmitWindowedPoSt(t *testing.T) { + tests := []test{} + runTest(t, miner.SubmitWindowedPoSt, tests) +} + +func TestConfirmSectorProofsValid(t *testing.T) { + tests := []test{} + runTest(t, miner.ConfirmSectorProofsValid, tests) +} + +func TestCheckSectorProven(t *testing.T) { + tests := []test{} + runTest(t, miner.CheckSectorProven, tests) +} + +func TestExtendSectorExpiration(t *testing.T) { + tests := []test{} + runTest(t, miner.ExtendSectorExpiration, tests) +} + +func TestCompactSectorNumbers(t *testing.T) { + tests := []test{} + runTest(t, miner.CompactSectorNumbers, tests) +} + +func TestCompactPartitions(t *testing.T) { + tests := []test{} + runTest(t, miner.CompactPartitions, tests) +} + +func TestPreCommitSectorBatch(t *testing.T) { + tests := []test{} + runTest(t, miner.PreCommitSectorBatch, tests) +} + +func TestGetSectorSize(t *testing.T) { + tests := []test{} + runTest(t, miner.GetSectorSize, tests) +} + +func TestProveCommitSectors3(t *testing.T) { + tests := []test{} + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.height, tt.version) + require.NoError(t, err) + + for _, trace := range computeState.Trace { + if trace.Msg == nil { + continue + } + + result, err := miner.ProveCommitSectors3(tt.height, trace.Msg.Params, trace.MsgRct.Return) + require.NoError(t, err) + require.True(t, tools.CompareResult(result, tt.expected)) + + } + }) + } +} diff --git a/actors/multisig/generic.go b/actors/multisig/generic.go index ed82a0cb..99df1bb5 100644 --- a/actors/multisig/generic.go +++ b/actors/multisig/generic.go @@ -13,7 +13,7 @@ import ( func parseWithMsigParser[T multisigParams, R multisigReturn](msg *parser.LotusMessage, height int64, key filTypes.TipSetKey, - fn parseFn, + fn ParseFn, rawReturn []byte, unmarshaller func(io.Reader, any) error, customReturn bool, diff --git a/actors/multisig/multisig.go b/actors/multisig/multisig.go index 46f1513a..bd3b2063 100644 --- a/actors/multisig/multisig.go +++ b/actors/multisig/multisig.go @@ -39,7 +39,7 @@ func MsigConstructor(height int64, raw []byte) (map[string]interface{}, error) { return map[string]interface{}{}, nil } -func MsigParams(msg *parser.LotusMessage, height int64, key filTypes.TipSetKey, parser parseFn) (map[string]interface{}, error) { +func MsigParams(msg *parser.LotusMessage, height int64, key filTypes.TipSetKey, parser ParseFn) (map[string]interface{}, error) { switch { case tools.V8.IsSupported(height): return parseWithMsigParser[*multisig8.ConstructorParams, *multisig8.ConstructorParams](msg, height, key, parser, nil, jsonUnmarshaller[*multisig8.ConstructorParams], false) @@ -61,7 +61,7 @@ func MsigParams(msg *parser.LotusMessage, height int64, key filTypes.TipSetKey, return map[string]interface{}{}, nil } -func Approve(msg *parser.LotusMessage, height int64, key filTypes.TipSetKey, rawReturn []byte, parser parseFn) (map[string]interface{}, error) { +func Approve(msg *parser.LotusMessage, height int64, key filTypes.TipSetKey, rawReturn []byte, parser ParseFn) (map[string]interface{}, error) { switch { case tools.V8.IsSupported(height): return parseWithMsigParser[*multisig8.ApproveReturn, *multisig8.ApproveReturn](msg, height, key, parser, rawReturn, cborUnmarshaller[*multisig8.ApproveReturn], true) @@ -83,7 +83,7 @@ func Approve(msg *parser.LotusMessage, height int64, key filTypes.TipSetKey, raw return map[string]interface{}{}, nil } -func Cancel(msg *parser.LotusMessage, height int64, key filTypes.TipSetKey, rawReturn []byte, parser parseFn) (map[string]interface{}, error) { +func Cancel(msg *parser.LotusMessage, height int64, key filTypes.TipSetKey, rawReturn []byte, parser ParseFn) (map[string]interface{}, error) { switch { case tools.V8.IsSupported(height): return parseWithMsigParser[metadataWithCbor, metadataWithCbor](msg, height, key, parser, rawReturn, noopUnmarshaller[metadataWithCbor], false) @@ -105,7 +105,7 @@ func Cancel(msg *parser.LotusMessage, height int64, key filTypes.TipSetKey, rawR return map[string]interface{}{}, nil } -func RemoveSigner(msg *parser.LotusMessage, height int64, key filTypes.TipSetKey, rawReturn []byte, parser parseFn) (map[string]interface{}, error) { +func RemoveSigner(msg *parser.LotusMessage, height int64, key filTypes.TipSetKey, rawReturn []byte, parser ParseFn) (map[string]interface{}, error) { switch { case tools.V8.IsSupported(height): return parseWithMsigParser[metadataWithCbor, metadataWithCbor](msg, height, key, parser, rawReturn, noopUnmarshaller[metadataWithCbor], false) @@ -127,7 +127,7 @@ func RemoveSigner(msg *parser.LotusMessage, height int64, key filTypes.TipSetKey return map[string]interface{}{}, nil } -func ChangeNumApprovalsThreshold(msg *parser.LotusMessage, height int64, key filTypes.TipSetKey, rawReturn []byte, parser parseFn) (map[string]interface{}, error) { +func ChangeNumApprovalsThreshold(msg *parser.LotusMessage, height int64, key filTypes.TipSetKey, rawReturn []byte, parser ParseFn) (map[string]interface{}, error) { switch { case tools.V8.IsSupported(height): return parse[*multisig8.ChangeNumApprovalsThresholdParams, []byte](rawReturn, cborUnmarshaller[*multisig8.ChangeNumApprovalsThresholdParams]) @@ -149,7 +149,7 @@ func ChangeNumApprovalsThreshold(msg *parser.LotusMessage, height int64, key fil return map[string]interface{}{}, nil } -func LockBalance(msg *parser.LotusMessage, height int64, key filTypes.TipSetKey, rawReturn []byte, parser parseFn) (map[string]interface{}, error) { +func LockBalance(msg *parser.LotusMessage, height int64, key filTypes.TipSetKey, rawReturn []byte, parser ParseFn) (map[string]interface{}, error) { switch { case tools.V8.IsSupported(height): return parse[*multisig8.LockBalanceParams, []byte](rawReturn, cborUnmarshaller[*multisig8.LockBalanceParams]) @@ -171,7 +171,7 @@ func LockBalance(msg *parser.LotusMessage, height int64, key filTypes.TipSetKey, return map[string]interface{}{}, nil } -func UniversalReceiverHook(msg *parser.LotusMessage, height int64, key filTypes.TipSetKey, rawReturn []byte, parser parseFn) (map[string]interface{}, error) { +func UniversalReceiverHook(msg *parser.LotusMessage, height int64, key filTypes.TipSetKey, rawReturn []byte, parser ParseFn) (map[string]interface{}, error) { switch { case tools.V8.IsSupported(height): return parse[*abi.CborBytesTransparent, []byte](rawReturn, cborUnmarshaller[*abi.CborBytesTransparent]) diff --git a/actors/multisig/multisig_test.go b/actors/multisig/multisig_test.go new file mode 100644 index 00000000..9da818bd --- /dev/null +++ b/actors/multisig/multisig_test.go @@ -0,0 +1,127 @@ +package multisig_test + +import ( + "testing" + + filTypes "github.com/filecoin-project/lotus/chain/types" + "github.com/stretchr/testify/require" + "github.com/zondax/fil-parser/actors/multisig" + "github.com/zondax/fil-parser/parser" + "github.com/zondax/fil-parser/tools" + + typesV2 "github.com/zondax/fil-parser/parser/v2/types" +) + +type testFn func(msg *parser.LotusMessage, height int64, key filTypes.TipSetKey, rawReturn []byte, parser multisig.ParseFn) (map[string]interface{}, error) +type tests struct { + name string + height int64 + version string + expected map[string]interface{} + tipsetKey filTypes.TipSetKey +} + +func TestApprove(t *testing.T) { + tests := []tests{} + runTest(t, multisig.Approve, tests) +} + +func TestCancel(t *testing.T) { + tests := []tests{} + runTest(t, multisig.Cancel, tests) +} + +func TestRemoveSigner(t *testing.T) { + tests := []tests{} + runTest(t, multisig.RemoveSigner, tests) +} + +func TestChangeNumApprovalsThreshold(t *testing.T) { + tests := []tests{} + runTest(t, multisig.ChangeNumApprovalsThreshold, tests) +} + +func TestLockBalance(t *testing.T) { + tests := []tests{} + runTest(t, multisig.LockBalance, tests) +} + +func TestUniversalReceiverHook(t *testing.T) { + tests := []tests{} + runTest(t, multisig.UniversalReceiverHook, tests) +} + +func TestMsigConstructor(t *testing.T) { + tests := []tests{} + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.height, tt.version) + require.NoError(t, err) + + for _, trace := range computeState.Trace { + if trace.Msg == nil { + continue + } + + result, err := multisig.MsigConstructor(tt.height, trace.MsgRct.Return) + require.NoError(t, err) + require.True(t, tools.CompareResult(result, tt.expected)) + + } + }) + } +} +func TestMsigParams(t *testing.T) { + tests := []tests{} + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.height, tt.version) + require.NoError(t, err) + + for _, trace := range computeState.Trace { + if trace.Msg == nil { + continue + } + + lotusMsg := &parser.LotusMessage{ + To: trace.Msg.To, + From: trace.Msg.From, + Method: trace.Msg.Method, + } + result, err := multisig.MsigParams(lotusMsg, tt.height, tt.tipsetKey, func(*parser.LotusMessage, int64, filTypes.TipSetKey) (string, error) { + return "", nil + }) + require.NoError(t, err) + require.True(t, tools.CompareResult(result, tt.expected)) + + } + }) + } +} + +func runTest(t *testing.T, fn testFn, tests []tests) { + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.height, tt.version) + require.NoError(t, err) + + for _, trace := range computeState.Trace { + if trace.Msg == nil { + continue + } + + lotusMsg := &parser.LotusMessage{ + To: trace.Msg.To, + From: trace.Msg.From, + Method: trace.Msg.Method, + } + result, err := fn(lotusMsg, tt.height, tt.tipsetKey, trace.MsgRct.Return, func(*parser.LotusMessage, int64, filTypes.TipSetKey) (string, error) { + return "", nil + }) + require.NoError(t, err) + require.True(t, tools.CompareResult(result, tt.expected)) + + } + }) + } +} diff --git a/actors/multisig/types.go b/actors/multisig/types.go index 0e82d487..05fd5987 100644 --- a/actors/multisig/types.go +++ b/actors/multisig/types.go @@ -15,7 +15,7 @@ type multisigReturn interface { UnmarshalCBOR(io.Reader) error } -type parseFn func(*parser.LotusMessage, int64, filTypes.TipSetKey) (string, error) +type ParseFn func(*parser.LotusMessage, int64, filTypes.TipSetKey) (string, error) type metadataWithCbor map[string]interface{} diff --git a/actors/multisig/values_test.go b/actors/multisig/values_test.go new file mode 100644 index 00000000..d58284fa --- /dev/null +++ b/actors/multisig/values_test.go @@ -0,0 +1,104 @@ +package multisig_test + +import ( + "reflect" + "testing" + + "github.com/stretchr/testify/require" + "github.com/zondax/fil-parser/actors/multisig" + typesV2 "github.com/zondax/fil-parser/parser/v2/types" + "github.com/zondax/fil-parser/tools" +) + +type valueTestFn func(height int64, txMetadata string) (interface{}, error) + +type test struct { + name string + height int64 + version string + expected interface{} +} + +func TestChangeOwnerAddressValue(t *testing.T) { + tests := []test{} + runValueTest(t, multisig.ChangeOwnerAddressValue, tests) +} + +func TestParseWithdrawBalanceValue(t *testing.T) { + tests := []test{} + runValueTest(t, multisig.ParseWithdrawBalanceValue, tests) +} + +func TestParseInvokeContractValue(t *testing.T) { + tests := []test{} + runValueTest(t, multisig.ParseInvokeContractValue, tests) +} + +func TestParseAddSignerValue(t *testing.T) { + tests := []test{} + runValueTest(t, multisig.ParseAddSignerValue, tests) +} + +func TestParseApproveValue(t *testing.T) { + tests := []test{} + runValueTest(t, multisig.ParseApproveValue, tests) +} + +func TestParseCancelValue(t *testing.T) { + tests := []test{} + runValueTest(t, multisig.ParseCancelValue, tests) +} +func TestChangeNumApprovalsThresholdValue(t *testing.T) { + tests := []test{} + runValueTest(t, multisig.ChangeNumApprovalsThresholdValue, tests) +} + +func TestParseConstructorValue(t *testing.T) { + tests := []test{} + runValueTest(t, multisig.ParseConstructorValue, tests) +} + +func TestParseLockBalanceValue(t *testing.T) { + tests := []test{} + runValueTest(t, multisig.ParseLockBalanceValue, tests) +} + +func TestParseRemoveSignerValue(t *testing.T) { + tests := []test{} + runValueTest(t, multisig.ParseRemoveSignerValue, tests) +} + +func TestParseSendValue(t *testing.T) { + tests := []test{} + runValueTest(t, multisig.ParseSendValue, tests) +} + +func TestParseSwapSignerValue(t *testing.T) { + tests := []test{} + runValueTest(t, multisig.ParseSwapSignerValue, tests) +} + +func TestParseUniversalReceiverHookValue(t *testing.T) { + tests := []test{} + runValueTest(t, multisig.ParseUniversalReceiverHookValue, tests) +} + +func runValueTest(t *testing.T, fn valueTestFn, tests []test) { + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.height, tt.version) + require.NoError(t, err) + + for _, trace := range computeState.Trace { + if trace.Msg == nil { + continue + } + // TODO: parse whole multisig tx first before calling this function + + result, err := fn(tt.height, string(trace.Msg.Params)) + require.NoError(t, err) + require.True(t, reflect.DeepEqual(result, tt.expected)) + } + }) + } +} diff --git a/actors/multisig/verifier_test.go b/actors/multisig/verifier_test.go new file mode 100644 index 00000000..cf12528a --- /dev/null +++ b/actors/multisig/verifier_test.go @@ -0,0 +1,12 @@ +package multisig_test + +import ( + "testing" + + "github.com/zondax/fil-parser/actors/multisig" +) + +func TestAddVerifierValue(t *testing.T) { + tests := []test{} + runValueTest(t, multisig.AddVerifierValue, tests) +} diff --git a/actors/paymentChannel/paymentChannel_test.go b/actors/paymentChannel/paymentChannel_test.go new file mode 100644 index 00000000..65a785fa --- /dev/null +++ b/actors/paymentChannel/paymentChannel_test.go @@ -0,0 +1,48 @@ +package paymentchannel_test + +import ( + "testing" + + "github.com/stretchr/testify/require" + paymentchannel "github.com/zondax/fil-parser/actors/paymentChannel" + typesV2 "github.com/zondax/fil-parser/parser/v2/types" + "github.com/zondax/fil-parser/tools" +) + +type testFn func(height int64, raw []byte) (map[string]interface{}, error) +type test struct { + name string + height int64 + version string + expected map[string]interface{} +} + +func TestPaymentChannelConstructor(t *testing.T) { + tests := []test{} + runTest(t, paymentchannel.PaymentChannelConstructor, tests) +} + +func TestUpdateChannelState(t *testing.T) { + tests := []test{} + runTest(t, paymentchannel.UpdateChannelState, tests) +} + +func runTest(t *testing.T, fn testFn, tests []test) { + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.height, tt.version) + require.NoError(t, err) + + for _, trace := range computeState.Trace { + if trace.Msg == nil { + continue + } + + result, err := fn(tt.height, trace.Msg.Params) + require.NoError(t, err) + require.True(t, tools.CompareResult(result, tt.expected)) + + } + }) + } +} diff --git a/actors/power/power_test.go b/actors/power/power_test.go new file mode 100644 index 00000000..e75026b9 --- /dev/null +++ b/actors/power/power_test.go @@ -0,0 +1,117 @@ +package power_test + +import ( + "testing" + + "github.com/stretchr/testify/require" + "github.com/zondax/fil-parser/actors/power" + "github.com/zondax/fil-parser/parser" + typesV2 "github.com/zondax/fil-parser/parser/v2/types" + "github.com/zondax/fil-parser/tools" +) + +type testFn func(msg *parser.LotusMessage, height int64, raw, rawReturn []byte) (map[string]interface{}, error) + +type test struct { + name string + height int64 + version string + expected map[string]interface{} +} + +func TestCurrentTotalPower(t *testing.T) { + tests := []test{} + runTest(t, power.CurrentTotalPower, tests) +} + +func TestSubmitPoRepForBulkVerify(t *testing.T) { + tests := []test{} + runTest(t, power.SubmitPoRepForBulkVerify, tests) +} + +func TestCreateMiner(t *testing.T) { + tests := []test{} + runTest(t, power.CreateMiner, tests) +} + +func TestEnrollCronEvent(t *testing.T) { + tests := []test{} + runTest(t, power.EnrollCronEvent, tests) +} + +func TestUpdateClaimedPower(t *testing.T) { + tests := []test{} + runTest(t, power.UpdateClaimedPower, tests) +} + +func TestUpdatePledgeTotal(t *testing.T) { + tests := []test{} + runTest(t, power.UpdatePledgeTotal, tests) +} + +func TestNetworkRawPower(t *testing.T) { + tests := []test{} + runTest(t, power.NetworkRawPower, tests) +} + +func TestMinerRawPower(t *testing.T) { + tests := []test{} + runTest(t, power.MinerRawPower, tests) +} + +func TestMinerCount(t *testing.T) { + tests := []test{} + runTest(t, power.MinerCount, tests) +} + +func TestMinerConsensusCount(t *testing.T) { + tests := []test{} + runTest(t, power.MinerConsensusCount, tests) +} + +func TestPowerConstructor(t *testing.T) { + tests := []test{} + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.height, tt.version) + require.NoError(t, err) + + for _, trace := range computeState.Trace { + if trace.Msg == nil { + continue + } + lotusMsg := &parser.LotusMessage{ + To: trace.Msg.To, + From: trace.Msg.From, + Method: trace.Msg.Method, + } + result, err := power.PowerConstructor(tt.height, lotusMsg, trace.Msg.Params) + require.NoError(t, err) + require.True(t, tools.CompareResult(result, tt.expected)) + } + }) + } +} + +func runTest(t *testing.T, fn testFn, tests []test) { + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.height, tt.version) + require.NoError(t, err) + + for _, trace := range computeState.Trace { + if trace.Msg == nil { + continue + } + lotusMsg := &parser.LotusMessage{ + To: trace.Msg.To, + From: trace.Msg.From, + Method: trace.Msg.Method, + } + result, err := fn(lotusMsg, tt.height, trace.Msg.Params, trace.MsgRct.Return) + require.NoError(t, err) + require.True(t, tools.CompareResult(result, tt.expected)) + } + }) + } +} diff --git a/actors/reward/reward_test.go b/actors/reward/reward_test.go new file mode 100644 index 00000000..0cd6110a --- /dev/null +++ b/actors/reward/reward_test.go @@ -0,0 +1,58 @@ +package reward_test + +import ( + "testing" + + "github.com/stretchr/testify/require" + "github.com/zondax/fil-parser/actors/reward" + typesV2 "github.com/zondax/fil-parser/parser/v2/types" + "github.com/zondax/fil-parser/tools" +) + +type testFn func(height int64, raw []byte) (map[string]interface{}, error) + +type test struct { + name string + height int64 + version string + expected map[string]interface{} +} + +func TestRewardConstructor(t *testing.T) { + tests := []test{} + runTest(t, reward.RewardConstructor, tests) +} + +func TestAwardBlockReward(t *testing.T) { + tests := []test{} + runTest(t, reward.AwardBlockReward, tests) +} + +func TestUpdateNetworkKPI(t *testing.T) { + tests := []test{} + runTest(t, reward.UpdateNetworkKPI, tests) +} + +func TestThisEpochReward(t *testing.T) { + tests := []test{} + runTest(t, reward.ThisEpochReward, tests) +} + +func runTest(t *testing.T, fn testFn, tests []test) { + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.height, tt.version) + require.NoError(t, err) + + for _, trace := range computeState.Trace { + if trace.Msg == nil { + continue + } + + result, err := fn(tt.height, trace.Msg.Params) + require.NoError(t, err) + require.True(t, tools.CompareResult(result, tt.expected)) + } + }) + } +} diff --git a/actors/verifiedRegistry/verifiedRegistry_test.go b/actors/verifiedRegistry/verifiedRegistry_test.go new file mode 100644 index 00000000..c8a2da96 --- /dev/null +++ b/actors/verifiedRegistry/verifiedRegistry_test.go @@ -0,0 +1,126 @@ +package verifiedregistry_test + +import ( + "testing" + + "github.com/stretchr/testify/require" + verifiedregistry "github.com/zondax/fil-parser/actors/verifiedRegistry" + typesV2 "github.com/zondax/fil-parser/parser/v2/types" + "github.com/zondax/fil-parser/tools" +) + +type testFn func(height int64, raw []byte) (map[string]interface{}, error) +type testFn2 func(height int64, raw, rawReturn []byte) (map[string]interface{}, error) +type test struct { + name string + height int64 + version string + expected map[string]interface{} +} + +func TestAddVerifier(t *testing.T) { + tests := []test{} + runTest(t, verifiedregistry.AddVerifier, tests) +} + +func TestRemoveVerifier(t *testing.T) { + tests := []test{} + runTest(t, verifiedregistry.RemoveVerifier, tests) +} + +func TestAddVerifiedClient(t *testing.T) { + tests := []test{} + runTest(t, verifiedregistry.AddVerifiedClient, tests) +} + +func TestUseBytes(t *testing.T) { + tests := []test{} + runTest(t, verifiedregistry.UseBytes, tests) +} + +func TestRestoreBytes(t *testing.T) { + tests := []test{} + runTest(t, verifiedregistry.RestoreBytes, tests) +} + +func TestRemoveVerifiedClientDataCap(t *testing.T) { + tests := []test{} + runTest(t, verifiedregistry.RemoveVerifiedClientDataCap, tests) +} + +func TestDeprecated1(t *testing.T) { + tests := []test{} + runTest(t, verifiedregistry.Deprecated1, tests) +} + +func TestDeprecated2(t *testing.T) { + tests := []test{} + runTest(t, verifiedregistry.Deprecated2, tests) +} + +func TestClaimAllocations(t *testing.T) { + tests := []test{} + runTest2(t, verifiedregistry.ClaimAllocations, tests) +} + +func TestGetClaims(t *testing.T) { + tests := []test{} + runTest2(t, verifiedregistry.GetClaims, tests) +} + +func TestExtendClaimTerms(t *testing.T) { + tests := []test{} + runTest2(t, verifiedregistry.ExtendClaimTerms, tests) +} + +func TestRemoveExpiredClaims(t *testing.T) { + tests := []test{} + runTest2(t, verifiedregistry.RemoveExpiredClaims, tests) +} + +func TestVerifregUniversalReceiverHook(t *testing.T) { + tests := []test{} + runTest2(t, verifiedregistry.VerifregUniversalReceiverHook, tests) +} +func TestRemoveExpiredAllocations(t *testing.T) { + tests := []test{} + runTest2(t, verifiedregistry.RemoveExpiredAllocations, tests) +} + +func runTest(t *testing.T, fn testFn, tests []test) { + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.height, tt.version) + require.NoError(t, err) + + for _, trace := range computeState.Trace { + if trace.Msg == nil { + continue + } + + result, err := fn(tt.height, trace.Msg.Params) + require.NoError(t, err) + require.True(t, tools.CompareResult(result, tt.expected)) + } + }) + } +} + +func runTest2(t *testing.T, fn testFn2, tests []test) { + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.height, tt.version) + require.NoError(t, err) + + for _, trace := range computeState.Trace { + if trace.Msg == nil { + continue + } + + result, err := fn(tt.height, trace.Msg.Params, trace.MsgRct.Return) + require.NoError(t, err) + require.True(t, tools.CompareResult(result, tt.expected)) + } + }) + } +} diff --git a/tools/testutil.go b/tools/testutil.go new file mode 100644 index 00000000..f6070bd6 --- /dev/null +++ b/tools/testutil.go @@ -0,0 +1,158 @@ +package tools + +import ( + "bytes" + "compress/gzip" + "context" + "fmt" + "net/http" + "os" + "reflect" + + "github.com/bytedance/sonic" + "github.com/filecoin-project/lotus/api" + "github.com/filecoin-project/lotus/api/client" + filTypes "github.com/filecoin-project/lotus/chain/types" + "github.com/zondax/fil-parser/types" + rosettaFilecoinLib "github.com/zondax/rosetta-filecoin-lib" +) + +const ( + dataPath = "data/heights" + fileDataExtension = "json.gz" + tracesPrefix = "traces" + tipsetPrefix = "tipset" + ethLogPrefix = "ethlog" + nativeLogPrefix = "nativelog" + NodeUrl = "https://node-fil-mainnet-next.zondax.ch/rpc/v1" + calibNextNodeUrl = "https://hel1-node-fil-calibration-stable.zondax.ch/rpc/v1" + feeType = "fee" +) + +func getLotusClient(url string) (api.FullNode, error) { + lotusClient, _, err := client.NewFullNodeRPCV1(context.Background(), url, http.Header{}) + if err != nil { + return nil, err + } + return lotusClient, nil +} + +func GetLib(nodeURL string) (*rosettaFilecoinLib.RosettaConstructionFilecoin, error) { + lotusClient, err := getLotusClient(nodeURL) + if err != nil { + return nil, err + } + + lib := rosettaFilecoinLib.NewRosettaConstructionFilecoin(lotusClient) + return lib, nil +} + +func getFilename(prefix string, height int64) string { + return fmt.Sprintf(`%s/%s_%d.%s`, dataPath, prefix, height, fileDataExtension) +} + +func tracesFilename(height int64) string { + return getFilename(tracesPrefix, height) +} + +func ehtlogFilename(height int64) string { + return getFilename(ethLogPrefix, height) +} + +func nativeLogFilename(height int64) string { + return getFilename(nativeLogPrefix, height) +} + +func tipsetFilename(height int64) string { + return getFilename(tipsetPrefix, height) +} + +func read[T any](fileNameFn func(height int64) string, height int64) (*T, error) { + raw, err := readGzFile(fileNameFn(height)) + if err != nil { + return nil, err + } + var r T + err = sonic.Unmarshal(raw, &r) + if err != nil { + return nil, err + } + return &r, nil +} + +func readGzFile(fileName string) ([]byte, error) { + file, err := os.Open(fileName) + if err != nil { + return nil, err + } + defer file.Close() + gzipReader, err := gzip.NewReader(file) + if err != nil { + return nil, err + } + defer gzipReader.Close() + buf := new(bytes.Buffer) + _, err = buf.ReadFrom(gzipReader) + if err != nil { + return nil, err + } + return buf.Bytes(), nil +} + +func ReadTipset(height int64) (*types.ExtendedTipSet, error) { + return read[types.ExtendedTipSet](tipsetFilename, height) +} + +func ReadEthLogs(height int64) ([]types.EthLog, error) { + logs, err := read[[]types.EthLog](ehtlogFilename, height) + if err != nil { + return nil, err + } + return *logs, nil +} + +func ReadNativeLogs(height int64) ([]*filTypes.ActorEvent, error) { + events, err := read[[]*filTypes.ActorEvent](nativeLogFilename, height) + if err != nil { + return nil, err + } + return *events, nil +} + +func ReadTraces(height int64) ([]byte, error) { + return readGzFile(tracesFilename(height)) +} + +func ComputeState[T any](height int64, version string) (*T, error) { + tipset, err := ReadTipset(height) + if err != nil { + return nil, err + } + ethlogs, err := ReadEthLogs(height) + if err != nil { + return nil, err + } + traces, err := ReadTraces(height) + if err != nil { + return nil, err + } + + txsData := types.TxsData{ + EthLogs: ethlogs, + Tipset: tipset, + Traces: traces, + Metadata: types.BlockMetadata{NodeInfo: types.NodeInfo{NodeMajorMinorVersion: version}}, + } + + var computeState T + err = sonic.UnmarshalString(string(txsData.Traces), &computeState) + if err != nil { + return nil, err + } + return &computeState, nil + +} + +func CompareResult(result1, result2 map[string]any) bool { + return reflect.DeepEqual(result1, result2) +} From 56062101407e7c08981682550fb558f72ef78b94 Mon Sep 17 00:00:00 2001 From: Eric Mokaya Date: Wed, 22 Jan 2025 13:11:25 +0300 Subject: [PATCH 07/16] fix: fix build --- actors/account.go | 46 +++++++++++++++-- actors/actor.go | 2 +- actors/datacap/burn.go | 7 ++- actors/eam/create.go | 8 +-- actors/eam/eam.go | 12 ++--- actors/miner/address.go | 16 +++--- actors/miner/balance.go | 8 +-- actors/miner/miner.go | 2 +- actors/miner/sector.go | 55 +++++++++++---------- actors/power/power.go | 26 ++++------ actors/verifiedRegistry/verifiedRegistry.go | 14 +++--- 11 files changed, 112 insertions(+), 84 deletions(-) diff --git a/actors/account.go b/actors/account.go index b7870f65..8166c831 100644 --- a/actors/account.go +++ b/actors/account.go @@ -1,22 +1,60 @@ package actors import ( - "github.com/zondax/fil-parser/actors/account" + "bytes" + "encoding/base64" + + "github.com/filecoin-project/go-address" + "github.com/filecoin-project/go-state-types/builtin/v9/account" "github.com/zondax/fil-parser/parser" + + typegen "github.com/whyrusleeping/cbor-gen" ) -func (p *ActorParser) ParseAccount(height int64, txType string, msg *parser.LotusMessage, msgRct *parser.LotusMessageReceipt) (map[string]interface{}, error) { +func (p *ActorParser) ParseAccount(txType string, msg *parser.LotusMessage, msgRct *parser.LotusMessageReceipt) (map[string]interface{}, error) { switch txType { case parser.MethodSend: return p.parseSend(msg), nil case parser.MethodConstructor: return p.parseConstructor(msg.Params) case parser.MethodPubkeyAddress: - return account.PubkeyAddress(msg.Params, msgRct.Return) + return p.pubkeyAddress(msg.Params, msgRct.Return) case parser.MethodAuthenticateMessage: - return account.AuthenticateMessage(height, msg.Params, msgRct.Return) + return p.authenticateMessage(msg.Params, msgRct.Return) case parser.UnknownStr: return p.unknownMetadata(msg.Params, msgRct.Return) } return map[string]interface{}{}, parser.ErrUnknownMethod } + +func (p *ActorParser) pubkeyAddress(raw, rawReturn []byte) (map[string]interface{}, error) { + metadata := make(map[string]interface{}) + metadata[parser.ParamsKey] = base64.StdEncoding.EncodeToString(raw) + reader := bytes.NewReader(rawReturn) + var r address.Address + err := r.UnmarshalCBOR(reader) + if err != nil { + return metadata, err + } + metadata[parser.ReturnKey] = r.String() + return metadata, nil +} + +func (p *ActorParser) authenticateMessage(raw, rawReturn []byte) (map[string]interface{}, error) { + metadata := make(map[string]interface{}) + reader := bytes.NewReader(raw) + var params account.AuthenticateMessageParams + err := params.UnmarshalCBOR(reader) + if err != nil { + return metadata, err + } + metadata[parser.ParamsKey] = params + reader = bytes.NewReader(rawReturn) + var expiredReturn typegen.CborBool + err = expiredReturn.UnmarshalCBOR(reader) + if err != nil { + return metadata, err + } + metadata[parser.ReturnKey] = expiredReturn + return metadata, nil +} diff --git a/actors/actor.go b/actors/actor.go index 7e9eec71..1aa34a1f 100644 --- a/actors/actor.go +++ b/actors/actor.go @@ -42,7 +42,7 @@ func (p *ActorParser) GetMetadata(txType string, msg *parser.LotusMessage, mainM case manifest.CronKey: metadata, err = p.ParseCron(txType, msg, msgRct) case manifest.AccountKey: - metadata, err = p.ParseAccount(height, txType, msg, msgRct) + metadata, err = p.ParseAccount(txType, msg, msgRct) case manifest.PowerKey: metadata, addressInfo, err = p.ParseStoragepower(txType, msg, msgRct) case manifest.MinerKey: diff --git a/actors/datacap/burn.go b/actors/datacap/burn.go index 736aa40e..ad452169 100644 --- a/actors/datacap/burn.go +++ b/actors/datacap/burn.go @@ -9,7 +9,6 @@ import ( datacapv13 "github.com/filecoin-project/go-state-types/builtin/v13/datacap" datacapv14 "github.com/filecoin-project/go-state-types/builtin/v14/datacap" datacapv15 "github.com/filecoin-project/go-state-types/builtin/v15/datacap" - datacapv8 "github.com/filecoin-project/go-state-types/builtin/v8/datacap" datacapv9 "github.com/filecoin-project/go-state-types/builtin/v9/datacap" "github.com/zondax/fil-parser/tools" ) @@ -17,7 +16,7 @@ import ( func BurnExported(height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch { case tools.V8.IsSupported(height): - return parse[*datacapv8.BurnParams, *datacapv8.BurnReturn](raw, rawReturn, true) + return nil, fmt.Errorf("not supported") case tools.V9.IsSupported(height): return parse[*datacapv9.BurnParams, *datacapv9.BurnReturn](raw, rawReturn, true) case tools.V10.IsSupported(height): @@ -39,7 +38,7 @@ func BurnExported(height int64, raw, rawReturn []byte) (map[string]interface{}, func BurnFromExported(height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch { case tools.V8.IsSupported(height): - return parse[*datacapv8.BurnFromParams, *datacapv8.BurnFromReturn](raw, rawReturn, true) + return nil, fmt.Errorf("not supported") case tools.V9.IsSupported(height): return parse[*datacapv9.BurnFromParams, *datacapv9.BurnFromReturn](raw, rawReturn, true) case tools.V10.IsSupported(height): @@ -61,7 +60,7 @@ func BurnFromExported(height int64, raw, rawReturn []byte) (map[string]interface func DestroyExported(height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch { case tools.V8.IsSupported(height): - return parse[*datacapv8.DestroyParams, *datacapv8.BurnReturn](raw, rawReturn, true) + return nil, fmt.Errorf("not supported") case tools.V9.IsSupported(height): return parse[*datacapv9.DestroyParams, *datacapv9.BurnReturn](raw, rawReturn, true) case tools.V10.IsSupported(height): diff --git a/actors/eam/create.go b/actors/eam/create.go index 9f91823b..05834656 100644 --- a/actors/eam/create.go +++ b/actors/eam/create.go @@ -9,7 +9,7 @@ import ( eamv13 "github.com/filecoin-project/go-state-types/builtin/v13/eam" eamv14 "github.com/filecoin-project/go-state-types/builtin/v14/eam" eamv15 "github.com/filecoin-project/go-state-types/builtin/v15/eam" - eamv9 "github.com/filecoin-project/go-state-types/builtin/v9/eam" + "github.com/ipfs/go-cid" "github.com/zondax/fil-parser/tools" "github.com/zondax/fil-parser/types" @@ -31,7 +31,7 @@ func ParseCreateExternal(height int64, rawParams, rawReturn []byte, msgCid cid.C case tools.V10.IsSupported(height): return parseCreate[*eamv10.CreateExternalReturn](rawParams, rawReturn, msgCid, external) case tools.V9.IsSupported(height): - return parseCreate[*eamv9.CreateExternalReturn](rawParams, rawReturn, msgCid, external) + return nil, nil, fmt.Errorf("unsupported height: %d", height) } return nil, nil, fmt.Errorf("unsupported height: %d", height) } @@ -52,7 +52,7 @@ func ParseCreate(height int64, rawParams, rawReturn []byte, msgCid cid.Cid) (map case tools.V10.IsSupported(height): return parseCreate[*eamv10.CreateReturn](rawParams, rawReturn, msgCid, external) case tools.V9.IsSupported(height): - return parseCreate[*eamv9.CreateReturn](rawParams, rawReturn, msgCid, external) + return nil, nil, fmt.Errorf("unsupported height: %d", height) } return nil, nil, fmt.Errorf("unsupported height: %d", height) } @@ -73,7 +73,7 @@ func ParseCreate2(height int64, rawParams, rawReturn []byte, msgCid cid.Cid) (ma case tools.V10.IsSupported(height): return parseCreate[*eamv10.Create2Return](rawParams, rawReturn, msgCid, external) case tools.V9.IsSupported(height): - return parseCreate[*eamv9.Create2Return](rawParams, rawReturn, msgCid, external) + return nil, nil, fmt.Errorf("unsupported height: %d", height) } return nil, nil, fmt.Errorf("unsupported height: %d", height) } diff --git a/actors/eam/eam.go b/actors/eam/eam.go index 7c6507e7..142de572 100644 --- a/actors/eam/eam.go +++ b/actors/eam/eam.go @@ -11,7 +11,7 @@ import ( eamv13 "github.com/filecoin-project/go-state-types/builtin/v13/eam" eamv14 "github.com/filecoin-project/go-state-types/builtin/v14/eam" eamv15 "github.com/filecoin-project/go-state-types/builtin/v15/eam" - eamv9 "github.com/filecoin-project/go-state-types/builtin/v9/eam" + "github.com/zondax/fil-parser/parser" ) @@ -53,12 +53,7 @@ func newEamCreate(r createReturn) parser.EamCreateReturn { RobustAddress: v.RobustAddress, EthAddress: parser.EthPrefix + hex.EncodeToString(v.EthAddress[:]), } - case *eamv9.CreateReturn: - return parser.EamCreateReturn{ - ActorId: v.ActorID, - RobustAddress: v.RobustAddress, - EthAddress: parser.EthPrefix + hex.EncodeToString(v.EthAddress[:]), - } + default: return parser.EamCreateReturn{} } @@ -91,8 +86,7 @@ func validateEamReturn(ret createReturn) error { return checkAndSetAddress(&v.RobustAddress) case *eamv10.CreateReturn: return checkAndSetAddress(&v.RobustAddress) - case *eamv9.CreateReturn: - return checkAndSetAddress(&v.RobustAddress) + } return nil diff --git a/actors/miner/address.go b/actors/miner/address.go index b99e56fd..f1a35be8 100644 --- a/actors/miner/address.go +++ b/actors/miner/address.go @@ -118,9 +118,9 @@ func IsControllingAddressExported(height int64, rawParams, rawReturn []byte) (ma case tools.V10.IsSupported(height): return parseGeneric[*miner10.IsControllingAddressParams, *miner10.IsControllingAddressReturn](rawParams, rawReturn, true) case tools.V9.IsSupported(height): - return parseGeneric[*miner9.IsControllingAddressParams, *miner9.IsControllingAddressReturn](rawParams, rawReturn, true) + return nil, fmt.Errorf("not supported") case tools.V8.IsSupported(height): - return parseGeneric[*miner8.IsControllingAddressParams, *miner8.IsControllingAddressReturn](rawParams, rawReturn, true) + return nil, fmt.Errorf("not supported") } return nil, fmt.Errorf("unsupported height: %d", height) } @@ -140,9 +140,9 @@ func GetOwner(height int64, rawReturn []byte) (map[string]interface{}, error) { case tools.V10.IsSupported(height): return parseGeneric[*miner10.GetOwnerReturn, *miner10.GetOwnerReturn](rawReturn, nil, false) case tools.V9.IsSupported(height): - return parseGeneric[*miner9.GetOwnerReturn, *miner9.GetOwnerReturn](rawReturn, nil, false) + return nil, fmt.Errorf("not supported") case tools.V8.IsSupported(height): - return parseGeneric[*miner8.GetOwnerReturn, *miner8.GetOwnerReturn](rawReturn, nil, false) + return nil, fmt.Errorf("not supported") } return nil, fmt.Errorf("unsupported height: %d", height) } @@ -162,9 +162,9 @@ func GetPeerID(height int64, rawReturn []byte) (map[string]interface{}, error) { case tools.V10.IsSupported(height): return parseGeneric[*miner10.GetPeerIDReturn, *miner10.GetPeerIDReturn](rawReturn, nil, false) case tools.V9.IsSupported(height): - return parseGeneric[*miner9.GetPeerIDReturn, *miner9.GetPeerIDReturn](rawReturn, nil, false) + return nil, fmt.Errorf("not supported") case tools.V8.IsSupported(height): - return parseGeneric[*miner8.GetPeerIDReturn, *miner8.GetPeerIDReturn](rawReturn, nil, false) + return nil, fmt.Errorf("not supported") } return nil, fmt.Errorf("unsupported height: %d", height) } @@ -184,9 +184,9 @@ func GetMultiaddrs(height int64, rawReturn []byte) (map[string]interface{}, erro case tools.V10.IsSupported(height): return parseGeneric[*miner10.GetMultiAddrsReturn, *miner10.GetMultiAddrsReturn](rawReturn, nil, false) case tools.V9.IsSupported(height): - return parseGeneric[*miner9.GetMultiAddrsReturn, *miner9.GetMultiAddrsReturn](rawReturn, nil, false) + return nil, fmt.Errorf("not supported") case tools.V8.IsSupported(height): - return parseGeneric[*miner8.GetMultiAddrsReturn, *miner8.GetMultiAddrsReturn](rawReturn, nil, false) + return nil, fmt.Errorf("not supported") } return nil, fmt.Errorf("unsupported height: %d", height) } diff --git a/actors/miner/balance.go b/actors/miner/balance.go index f03fb986..b5aa6bc7 100644 --- a/actors/miner/balance.go +++ b/actors/miner/balance.go @@ -29,9 +29,9 @@ func GetAvailableBalance(height int64, rawReturn []byte) (map[string]interface{} case tools.V10.IsSupported(height): return parseGeneric[*miner10.GetAvailableBalanceReturn, *miner10.GetAvailableBalanceReturn](rawReturn, nil, false) case tools.V9.IsSupported(height): - return parseGeneric[*miner9.GetAvailableBalanceReturn, *miner9.GetAvailableBalanceReturn](rawReturn, nil, false) + return nil, fmt.Errorf("not supported") case tools.V8.IsSupported(height): - return parseGeneric[*miner8.GetAvailableBalanceReturn, *miner8.GetAvailableBalanceReturn](rawReturn, nil, false) + return nil, fmt.Errorf("not supported") } return nil, fmt.Errorf("unsupported height: %d", height) } @@ -51,9 +51,9 @@ func GetVestingFunds(height int64, rawReturn []byte) (map[string]interface{}, er case tools.V10.IsSupported(height): return parseGeneric[*miner10.GetVestingFundsReturn, *miner10.GetVestingFundsReturn](rawReturn, nil, false) case tools.V9.IsSupported(height): - return parseGeneric[*miner9.GetVestingFundsReturn, *miner9.GetVestingFundsReturn](rawReturn, nil, false) + return nil, fmt.Errorf("not supported") case tools.V8.IsSupported(height): - return parseGeneric[*miner8.GetVestingFundsReturn, *miner8.GetVestingFundsReturn](rawReturn, nil, false) + return nil, fmt.Errorf("not supported") } return nil, fmt.Errorf("unsupported height: %d", height) } diff --git a/actors/miner/miner.go b/actors/miner/miner.go index e52fd789..0883e6c8 100644 --- a/actors/miner/miner.go +++ b/actors/miner/miner.go @@ -229,7 +229,7 @@ func ChangeBeneficiary(height int64, rawParams []byte) (map[string]interface{}, case tools.V9.IsSupported(height): return parseGeneric[*miner9.ChangeBeneficiaryParams, *miner9.ChangeBeneficiaryParams](rawParams, nil, false) case tools.V8.IsSupported(height): - return parseGeneric[*miner8.ChangeBeneficiaryParams, *miner8.ChangeBeneficiaryParams](rawParams, nil, false) + return nil, fmt.Errorf("not supported") } return nil, fmt.Errorf("unsupported height: %d", height) } diff --git a/actors/miner/sector.go b/actors/miner/sector.go index 17490e42..ce2793bc 100644 --- a/actors/miner/sector.go +++ b/actors/miner/sector.go @@ -11,7 +11,7 @@ import ( miner15 "github.com/filecoin-project/go-state-types/builtin/v15/miner" miner8 "github.com/filecoin-project/go-state-types/builtin/v8/miner" miner9 "github.com/filecoin-project/go-state-types/builtin/v9/miner" - "github.com/filecoin-project/lotus/chain/actors/builtin/tools" + "github.com/zondax/fil-parser/tools" ) func ExtendSectorExpiration2(height int64, rawParams []byte) (map[string]interface{}, error) { @@ -31,7 +31,7 @@ func ExtendSectorExpiration2(height int64, rawParams []byte) (map[string]interfa case tools.V9.IsSupported(height): return parseGeneric[*miner9.ExtendSectorExpiration2Params, *miner9.ExtendSectorExpiration2Params](rawParams, nil, false) case tools.V8.IsSupported(height): - return parseGeneric[*miner8.ExtendSectorExpiration2Params, *miner8.ExtendSectorExpiration2Params](rawParams, nil, false) + return nil, fmt.Errorf("not supported") } return nil, fmt.Errorf("unsupported height: %d", height) } @@ -89,15 +89,15 @@ func ProveCommitSectors3(height int64, rawParams, rawReturn []byte) (map[string] case tools.V13.IsSupported(height): return parseGeneric[*miner13.ProveCommitSectors3Params, *miner13.ProveCommitSectors3Return](rawParams, rawReturn, true) case tools.V12.IsSupported(height): - return parseGeneric[*miner12.ProveCommitSectors3Params, *miner12.ProveCommitSectors3Return](rawParams, rawReturn, true) + return nil, fmt.Errorf("not supported") case tools.V11.IsSupported(height): - return parseGeneric[*miner11.ProveCommitSectors3Params, *miner11.ProveCommitSectors3Return](rawParams, rawReturn, true) + return nil, fmt.Errorf("not supported") case tools.V10.IsSupported(height): - return parseGeneric[*miner10.ProveCommitSectors3Params, *miner10.ProveCommitSectors3Return](rawParams, rawReturn, true) + return nil, fmt.Errorf("not supported") case tools.V9.IsSupported(height): - return parseGeneric[*miner9.ProveCommitSectors3Params, *miner9.ProveCommitSectors3Return](rawParams, rawReturn, true) + return nil, fmt.Errorf("not supported") case tools.V8.IsSupported(height): - return parseGeneric[*miner8.ProveCommitSectors3Params, *miner8.ProveCommitSectors3Return](rawParams, rawReturn, true) + return nil, fmt.Errorf("not supported") } return nil, fmt.Errorf("unsupported height: %d", height) } @@ -127,9 +127,9 @@ func SubmitWindowedPoSt(height int64, rawParams []byte) (map[string]interface{}, func ConfirmSectorProofsValid(height int64, rawParams []byte) (map[string]interface{}, error) { switch { case tools.V15.IsSupported(height): - return parseGeneric[*miner15.ConfirmSectorProofsParams, *miner15.ConfirmSectorProofsParams](rawParams, nil, false) + return nil, fmt.Errorf("not supported") case tools.V14.IsSupported(height): - return parseGeneric[*miner14.ConfirmSectorProofsParams, *miner14.ConfirmSectorProofsParams](rawParams, nil, false) + return nil, fmt.Errorf("not supported") case tools.V13.IsSupported(height): return parseGeneric[*miner13.ConfirmSectorProofsParams, *miner13.ConfirmSectorProofsParams](rawParams, nil, false) case tools.V12.IsSupported(height): @@ -256,24 +256,25 @@ func PreCommitSectorBatch(height int64, rawParams []byte) (map[string]interface{ return nil, fmt.Errorf("unsupported height: %d", height) } +// TODO: miner.GetSectorSizeReturn does not implement UnmarshalCBOR func GetSectorSize(height int64, rawReturn []byte) (map[string]interface{}, error) { - switch { - case tools.V15.IsSupported(height): - return parseGeneric[*miner15.GetSectorSizeReturn, *miner15.GetSectorSizeReturn](rawReturn, nil, false) - case tools.V14.IsSupported(height): - return parseGeneric[*miner14.GetSectorSizeReturn, *miner14.GetSectorSizeReturn](rawReturn, nil, false) - case tools.V13.IsSupported(height): - return parseGeneric[*miner13.GetSectorSizeReturn, *miner13.GetSectorSizeReturn](rawReturn, nil, false) - case tools.V12.IsSupported(height): - return parseGeneric[*miner12.GetSectorSizeReturn, *miner12.GetSectorSizeReturn](rawReturn, nil, false) - case tools.V11.IsSupported(height): - return parseGeneric[*miner11.GetSectorSizeReturn, *miner11.GetSectorSizeReturn](rawReturn, nil, false) - case tools.V10.IsSupported(height): - return parseGeneric[*miner10.GetSectorSizeReturn, *miner10.GetSectorSizeReturn](rawReturn, nil, false) - case tools.V9.IsSupported(height): - return parseGeneric[*miner9.GetSectorSizeReturn, *miner9.GetSectorSizeReturn](rawReturn, nil, false) - case tools.V8.IsSupported(height): - return parseGeneric[*miner8.GetSectorSizeReturn, *miner8.GetSectorSizeReturn](rawReturn, nil, false) - } + // switch { + // case tools.V15.IsSupported(height): + // return parseGeneric[*miner15.GetSectorSizeReturn, *miner15.GetSectorSizeReturn](rawReturn, nil, false) + // case tools.V14.IsSupported(height): + // return parseGeneric[*miner14.GetSectorSizeReturn, *miner14.GetSectorSizeReturn](rawReturn, nil, false) + // case tools.V13.IsSupported(height): + // return parseGeneric[*miner13.GetSectorSizeReturn, *miner13.GetSectorSizeReturn](rawReturn, nil, false) + // case tools.V12.IsSupported(height): + // return parseGeneric[*miner12.GetSectorSizeReturn, *miner12.GetSectorSizeReturn](rawReturn, nil, false) + // case tools.V11.IsSupported(height): + // return parseGeneric[*miner11.GetSectorSizeReturn, *miner11.GetSectorSizeReturn](rawReturn, nil, false) + // case tools.V10.IsSupported(height): + // return parseGeneric[*miner10.GetSectorSizeReturn, *miner10.GetSectorSizeReturn](rawReturn, nil, false) + // case tools.V9.IsSupported(height): + // return nil, fmt.Errorf("not supported") + // case tools.V8.IsSupported(height): + // return nil, fmt.Errorf("not supported") + // } return nil, fmt.Errorf("unsupported height: %d", height) } diff --git a/actors/power/power.go b/actors/power/power.go index d4409607..83c22ba3 100644 --- a/actors/power/power.go +++ b/actors/power/power.go @@ -1,6 +1,8 @@ package power import ( + "fmt" + "github.com/filecoin-project/go-state-types/abi" powerv10 "github.com/filecoin-project/go-state-types/builtin/v10/power" powerv11 "github.com/filecoin-project/go-state-types/builtin/v11/power" @@ -203,11 +205,9 @@ func UpdatePledgeTotal(msg *parser.LotusMessage, height int64, raw, rawReturn [] func NetworkRawPower(msg *parser.LotusMessage, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch { case tools.V8.IsSupported(height): - data, _, err := parse[*powerv8.NetworkRawPowerReturn, *powerv8.NetworkRawPowerReturn](msg, raw, rawReturn, false) - return data, err + return nil, fmt.Errorf("not supported") case tools.V9.IsSupported(height): - data, _, err := parse[*powerv9.NetworkRawPowerReturn, *powerv9.NetworkRawPowerReturn](msg, raw, rawReturn, false) - return data, err + return nil, fmt.Errorf("not supported") case tools.V10.IsSupported(height): data, _, err := parse[*powerv10.NetworkRawPowerReturn, *powerv10.NetworkRawPowerReturn](msg, raw, rawReturn, false) return data, err @@ -233,11 +233,9 @@ func NetworkRawPower(msg *parser.LotusMessage, height int64, raw, rawReturn []by func MinerRawPower(msg *parser.LotusMessage, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch { case tools.V8.IsSupported(height): - data, _, err := parse[*powerv8.MinerRawPowerParams, *powerv8.MinerRawPowerReturn](msg, raw, rawReturn, true) - return data, err + return nil, fmt.Errorf("not supported") case tools.V9.IsSupported(height): - data, _, err := parse[*powerv9.MinerRawPowerParams, *powerv9.MinerRawPowerReturn](msg, raw, rawReturn, true) - return data, err + return nil, fmt.Errorf("not supported") case tools.V10.IsSupported(height): data, _, err := parse[*powerv10.MinerRawPowerParams, *powerv10.MinerRawPowerReturn](msg, raw, rawReturn, true) return data, err @@ -263,11 +261,9 @@ func MinerRawPower(msg *parser.LotusMessage, height int64, raw, rawReturn []byte func MinerCount(msg *parser.LotusMessage, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch { case tools.V8.IsSupported(height): - data, _, err := parse[*powerv8.MinerCountReturn, *powerv8.MinerCountReturn](msg, raw, rawReturn, false) - return data, err + return nil, fmt.Errorf("not supported") case tools.V9.IsSupported(height): - data, _, err := parse[*powerv9.MinerCountReturn, *powerv9.MinerCountReturn](msg, raw, rawReturn, false) - return data, err + return nil, fmt.Errorf("not supported") case tools.V10.IsSupported(height): data, _, err := parse[*powerv10.MinerCountReturn, *powerv10.MinerCountReturn](msg, raw, rawReturn, false) return data, err @@ -293,11 +289,9 @@ func MinerCount(msg *parser.LotusMessage, height int64, raw, rawReturn []byte) ( func MinerConsensusCount(msg *parser.LotusMessage, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch { case tools.V8.IsSupported(height): - data, _, err := parse[*powerv8.MinerConsensusCountReturn, *powerv8.MinerConsensusCountReturn](msg, raw, rawReturn, false) - return data, err + return nil, fmt.Errorf("not supported") case tools.V9.IsSupported(height): - data, _, err := parse[*powerv9.MinerConsensusCountReturn, *powerv9.MinerConsensusCountReturn](msg, raw, rawReturn, false) - return data, err + return nil, fmt.Errorf("not supported") case tools.V10.IsSupported(height): data, _, err := parse[*powerv10.MinerConsensusCountReturn, *powerv10.MinerConsensusCountReturn](msg, raw, rawReturn, false) return data, err diff --git a/actors/verifiedRegistry/verifiedRegistry.go b/actors/verifiedRegistry/verifiedRegistry.go index 398a836b..bf51decf 100644 --- a/actors/verifiedRegistry/verifiedRegistry.go +++ b/actors/verifiedRegistry/verifiedRegistry.go @@ -1,6 +1,8 @@ package verifiedregistry import ( + "fmt" + "github.com/filecoin-project/go-address" verifregv10 "github.com/filecoin-project/go-state-types/builtin/v10/verifreg" verifregv11 "github.com/filecoin-project/go-state-types/builtin/v11/verifreg" @@ -131,7 +133,7 @@ func RemoveVerifiedClientDataCap(height int64, raw []byte) (map[string]interface func RemoveExpiredAllocations(height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch { case tools.V8.IsSupported(height): - return parse[*verifregv8.RemoveExpiredAllocationsParams, *verifregv8.RemoveExpiredAllocationsReturn](raw, rawReturn, true) + return nil, fmt.Errorf("not supported") case tools.V9.IsSupported(height): return parse[*verifregv9.RemoveExpiredAllocationsParams, *verifregv9.RemoveExpiredAllocationsReturn](raw, rawReturn, true) case tools.V10.IsSupported(height): @@ -197,7 +199,7 @@ func Deprecated2(height int64, raw []byte) (map[string]interface{}, error) { func ClaimAllocations(height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch { case tools.V8.IsSupported(height): - return parse[*verifregv8.ClaimAllocationsParams, *verifregv8.ClaimAllocationsReturn](raw, rawReturn, true) + return nil, fmt.Errorf("not supported") case tools.V9.IsSupported(height): return parse[*verifregv9.ClaimAllocationsParams, *verifregv9.ClaimAllocationsReturn](raw, rawReturn, true) case tools.V10.IsSupported(height): @@ -219,7 +221,7 @@ func ClaimAllocations(height int64, raw, rawReturn []byte) (map[string]interface func GetClaims(height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch { case tools.V8.IsSupported(height): - return parse[*verifregv8.GetClaimsParams, *verifregv8.GetClaimsReturn](raw, rawReturn, true) + return nil, fmt.Errorf("not supported") case tools.V9.IsSupported(height): return parse[*verifregv9.GetClaimsParams, *verifregv9.GetClaimsReturn](raw, rawReturn, true) case tools.V10.IsSupported(height): @@ -241,7 +243,7 @@ func GetClaims(height int64, raw, rawReturn []byte) (map[string]interface{}, err func ExtendClaimTerms(height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch { case tools.V8.IsSupported(height): - return parse[*verifregv8.ExtendClaimTermsParams, *verifregv8.ExtendClaimTermsReturn](raw, rawReturn, true) + return nil, fmt.Errorf("not supported") case tools.V9.IsSupported(height): return parse[*verifregv9.ExtendClaimTermsParams, *verifregv9.ExtendClaimTermsReturn](raw, rawReturn, true) case tools.V10.IsSupported(height): @@ -263,7 +265,7 @@ func ExtendClaimTerms(height int64, raw, rawReturn []byte) (map[string]interface func RemoveExpiredClaims(height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch { case tools.V8.IsSupported(height): - return parse[*verifregv8.RemoveExpiredClaimsParams, *verifregv8.RemoveExpiredClaimsReturn](raw, rawReturn, true) + return nil, fmt.Errorf("not supported") case tools.V9.IsSupported(height): return parse[*verifregv9.RemoveExpiredClaimsParams, *verifregv9.RemoveExpiredClaimsReturn](raw, rawReturn, true) case tools.V10.IsSupported(height): @@ -285,7 +287,7 @@ func RemoveExpiredClaims(height int64, raw, rawReturn []byte) (map[string]interf func VerifregUniversalReceiverHook(height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch { case tools.V8.IsSupported(height): - return parse[*verifregv8.UniversalReceiverParams, *verifregv8.AllocationsResponse](raw, rawReturn, true) + return nil, fmt.Errorf("not supported") case tools.V9.IsSupported(height): return parse[*verifregv9.UniversalReceiverParams, *verifregv9.AllocationsResponse](raw, rawReturn, true) case tools.V10.IsSupported(height): From 8cf33c20fd51f499748b7b64f8f806d68152b58d Mon Sep 17 00:00:00 2001 From: Eric Mokaya Date: Wed, 22 Jan 2025 13:14:10 +0300 Subject: [PATCH 08/16] chore: go mod tidy --- go.mod | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/go.mod b/go.mod index fe45b2a0..d1dc48cd 100644 --- a/go.mod +++ b/go.mod @@ -88,12 +88,12 @@ require ( github.com/filecoin-project/go-hamt-ipld/v2 v2.0.0 // indirect github.com/filecoin-project/go-hamt-ipld/v3 v3.4.0 // indirect github.com/filecoin-project/go-jsonrpc v0.7.1 - github.com/filecoin-project/specs-actors/v2 v2.3.6 // indirect - github.com/filecoin-project/specs-actors/v3 v3.1.2 // indirect - github.com/filecoin-project/specs-actors/v4 v4.0.2 // indirect - github.com/filecoin-project/specs-actors/v5 v5.0.6 // indirect - github.com/filecoin-project/specs-actors/v6 v6.0.2 // indirect - github.com/filecoin-project/specs-actors/v7 v7.0.1 // indirect + github.com/filecoin-project/specs-actors/v2 v2.3.6 + github.com/filecoin-project/specs-actors/v3 v3.1.2 + github.com/filecoin-project/specs-actors/v4 v4.0.2 + github.com/filecoin-project/specs-actors/v5 v5.0.6 + github.com/filecoin-project/specs-actors/v6 v6.0.2 + github.com/filecoin-project/specs-actors/v7 v7.0.1 github.com/fsnotify/fsnotify v1.7.0 // indirect github.com/gbrlsnchs/jwt/v3 v3.0.1 // indirect github.com/go-chi/chi/v5 v5.0.11 // indirect From 53aab64e05c99afec22cee2d7befe62ce7283984 Mon Sep 17 00:00:00 2001 From: Eric Mokaya Date: Wed, 22 Jan 2025 13:49:22 +0300 Subject: [PATCH 09/16] test: add expected results json --- actors/account/expected.json | 19 +++++++++++++ actors/cron/expected.json | 5 ++++ actors/datacap/expected.json | 17 ++++++++++++ actors/eam/expected.json | 8 ++++++ actors/evm/evm_test.go | 1 - actors/evm/expected.json | 11 ++++++++ actors/init/expected.json | 7 +++++ actors/market/expected.json | 22 +++++++++++++++ actors/miner/expected.json | 40 +++++++++++++++++++++++++++ actors/multisig/expected.json | 26 +++++++++++++++++ actors/paymentChannel/expected.json | 6 ++++ actors/power/expected.json | 15 ++++++++++ actors/reward/expected.json | 8 ++++++ actors/verifiedRegistry/expected.json | 18 ++++++++++++ 14 files changed, 202 insertions(+), 1 deletion(-) create mode 100644 actors/account/expected.json create mode 100644 actors/cron/expected.json create mode 100644 actors/datacap/expected.json create mode 100644 actors/eam/expected.json create mode 100644 actors/evm/expected.json create mode 100644 actors/init/expected.json create mode 100644 actors/market/expected.json create mode 100644 actors/miner/expected.json create mode 100644 actors/multisig/expected.json create mode 100644 actors/paymentChannel/expected.json create mode 100644 actors/power/expected.json create mode 100644 actors/reward/expected.json create mode 100644 actors/verifiedRegistry/expected.json diff --git a/actors/account/expected.json b/actors/account/expected.json new file mode 100644 index 00000000..625ca337 --- /dev/null +++ b/actors/account/expected.json @@ -0,0 +1,19 @@ + +{ + "V1": { + "PubkeyAddress": {}, + "AuthenticateMessage": {} + }, + "V2": { + "PubkeyAddress": {}, + "AuthenticateMessage": {} + }, + "V3": { + "PubkeyAddress": {}, + "AuthenticateMessage": {} + }, + "V4": { + "PubkeyAddress": {}, + "AuthenticateMessage": {} + } +} diff --git a/actors/cron/expected.json b/actors/cron/expected.json new file mode 100644 index 00000000..e25cf19a --- /dev/null +++ b/actors/cron/expected.json @@ -0,0 +1,5 @@ +{ + "V1": { + "CronConstructor": {} + } +} \ No newline at end of file diff --git a/actors/datacap/expected.json b/actors/datacap/expected.json new file mode 100644 index 00000000..4553d23e --- /dev/null +++ b/actors/datacap/expected.json @@ -0,0 +1,17 @@ +{ + "V1": { + "BurnExported": {}, + "BurnFromExported": {}, + "DestroyExported": {}, + "GranularityExported": {}, + "IncreaseAllowance": {}, + "DecreaseAllowance": {}, + "RevokeAllowance": {}, + "GetAllowance": {}, + "MintExported": {}, + "NameExported": {}, + "SymbolExported": {}, + "TotalSupplyExported": {}, + "TransferExported": {} + } +} \ No newline at end of file diff --git a/actors/eam/expected.json b/actors/eam/expected.json new file mode 100644 index 00000000..7f63b190 --- /dev/null +++ b/actors/eam/expected.json @@ -0,0 +1,8 @@ +{ + "V1": { + "ParseCreate": {}, + "ParseCreate2": {}, + "ParseCreateExternal": {}, + "GetExternal": {} + } +} \ No newline at end of file diff --git a/actors/evm/evm_test.go b/actors/evm/evm_test.go index 1490a502..41d01085 100644 --- a/actors/evm/evm_test.go +++ b/actors/evm/evm_test.go @@ -15,7 +15,6 @@ type testFn func(height int64, raw []byte) (map[string]interface{}, error) type test struct { name string version string - url string height int64 expected map[string]any } diff --git a/actors/evm/expected.json b/actors/evm/expected.json new file mode 100644 index 00000000..92f98dbe --- /dev/null +++ b/actors/evm/expected.json @@ -0,0 +1,11 @@ +{ + "V1": { + "InvokeContract": {}, + "Resurrect": {}, + "InvokeContractDelegate": {}, + "GetByteCode": {}, + "GetByteCodeHash": {}, + "EVMConstructor": {}, + "GetStorageAt": {} + } +} \ No newline at end of file diff --git a/actors/init/expected.json b/actors/init/expected.json new file mode 100644 index 00000000..6fa6966a --- /dev/null +++ b/actors/init/expected.json @@ -0,0 +1,7 @@ +{ + "V1": { + "InitConstructor": {}, + "ParseExec": {}, + "ParseExec4": {} + } +} \ No newline at end of file diff --git a/actors/market/expected.json b/actors/market/expected.json new file mode 100644 index 00000000..3d2c843b --- /dev/null +++ b/actors/market/expected.json @@ -0,0 +1,22 @@ +{ + "V1": { + "ParseAddBalance": {}, + "ParseWithdrawBalance": {}, + "PublishStorageDealsParams": {}, + "VerifyDealsForActivationParams": {}, + "ActivateDealsParams": {}, + "OnMinerSectorsTerminateParams": {}, + "ComputeDataCommitmentParams": {}, + "GetBalanceParams": {}, + "GetDealDataCommitmentParams": {}, + "GetDealClientParams": {}, + "GetDealProviderParams": {}, + "GetDealLabelParams": {}, + "GetDealTermParams": {}, + "GetDealTotalPriceParams": {}, + "GetDealClientCollateralParams": {}, + "GetDealProviderCollateralParams": {}, + "GetDealVerifiedParams": {}, + "GetDealActivationParams": {} + } +} \ No newline at end of file diff --git a/actors/miner/expected.json b/actors/miner/expected.json new file mode 100644 index 00000000..6a0820c4 --- /dev/null +++ b/actors/miner/expected.json @@ -0,0 +1,40 @@ +{ + "V1": { + "ChangeMultiaddrs": {}, + "ChangePeerID": {}, + "ChangeWorkerAddress": {}, + "ChangeOwnerAddress": {}, + "IsControllingAddressExported": {}, + "GetOwner": {}, + "GetPeerID": {}, + "GetMultiaddrs": {}, + "GetAvailableBalance": {}, + "GetVestingFunds": {}, + "ParseWithdrawBalance": {}, + "TerminateSectors": {}, + "DeclareFaults": {}, + "DeclareFaultsRecovered": {}, + "ProveReplicaUpdates": {}, + "PreCommitSectorBatch2": {}, + "ProveReplicaUpdates2": {}, + "ProveCommitAggregate": {}, + "DisputeWindowedPoSt": {}, + "ReportConsensusFault": {}, + "ChangeBeneficiary": {}, + "MinerConstructor": {}, + "ApplyRewards": {}, + "OnDeferredCronEvent": {}, + "ExtendSectorExpiration2": {}, + "PreCommitSector": {}, + "ProveCommitSector": {}, + "ProveCommitSectors3": {}, + "SubmitWindowedPoSt": {}, + "ConfirmSectorProofsValid": {}, + "CheckSectorProven": {}, + "ExtendSectorExpiration": {}, + "CompactSectorNumbers": {}, + "CompactPartitions": {}, + "PreCommitSectorBatch": {}, + "GetSectorSize": {} + } +} \ No newline at end of file diff --git a/actors/multisig/expected.json b/actors/multisig/expected.json new file mode 100644 index 00000000..03b8f62c --- /dev/null +++ b/actors/multisig/expected.json @@ -0,0 +1,26 @@ +{ + "V1": { + "AddVerifierValue": {}, + "ChangeOwnerAddressValue": {}, + "ParseWithdrawBalanceValue": {}, + "ParseInvokeContractValue": {}, + "ParseAddSignerValue": {}, + "ParseApproveValue": {}, + "ParseCancelValue": {}, + "ChangeNumApprovalsThresholdValue": {}, + "ParseConstructorValue": {}, + "ParseLockBalanceValue": {}, + "ParseRemoveSignerValue": {}, + "ParseSendValue": {}, + "ParseSwapSignerValue": {}, + "ParseUniversalReceiverHookValue": {}, + "MsigConstructor": {}, + "MsigParams": {}, + "Approve": {}, + "Cancel": {}, + "RemoveSigner": {}, + "ChangeNumApprovalsThreshold": {}, + "LockBalance": {}, + "UniversalReceiverHook": {} + } +} \ No newline at end of file diff --git a/actors/paymentChannel/expected.json b/actors/paymentChannel/expected.json new file mode 100644 index 00000000..a2fa5a1a --- /dev/null +++ b/actors/paymentChannel/expected.json @@ -0,0 +1,6 @@ +{ + "V1": { + "PaymentChannelConstructor": {}, + "UpdateChannelState": {} + } +} \ No newline at end of file diff --git a/actors/power/expected.json b/actors/power/expected.json new file mode 100644 index 00000000..1e9dc4ac --- /dev/null +++ b/actors/power/expected.json @@ -0,0 +1,15 @@ +{ + "V1": { + "CurrentTotalPower": {}, + "SubmitPoRepForBulkVerify": {}, + "PowerConstructor": {}, + "CreateMiner": {}, + "EnrollCronEvent": {}, + "UpdateClaimedPower": {}, + "UpdatePledgeTotal": {}, + "NetworkRawPower": {}, + "MinerRawPower": {}, + "MinerCount": {}, + "MinerConsensusCount": {} + } +} \ No newline at end of file diff --git a/actors/reward/expected.json b/actors/reward/expected.json new file mode 100644 index 00000000..1b30035e --- /dev/null +++ b/actors/reward/expected.json @@ -0,0 +1,8 @@ +{ + "V1": { + "RewardConstructor": {}, + "AwardBlockReward": {}, + "UpdateNetworkKPI": {}, + "ThisEpochReward": {} + } +} \ No newline at end of file diff --git a/actors/verifiedRegistry/expected.json b/actors/verifiedRegistry/expected.json new file mode 100644 index 00000000..30f7af14 --- /dev/null +++ b/actors/verifiedRegistry/expected.json @@ -0,0 +1,18 @@ +{ + "V1": { + "AddVerifier": {}, + "RemoveVerifier": {}, + "AddVerifiedClient": {}, + "UseBytes": {}, + "RestoreBytes": {}, + "RemoveVerifiedClientDataCap": {}, + "RemoveExpiredAllocations": {}, + "Deprecated1": {}, + "Deprecated2": {}, + "ClaimAllocations": {}, + "GetClaims": {}, + "ExtendClaimTerms": {}, + "RemoveExpiredClaims": {}, + "VerifregUniversalReceiverHook": {} + } +} \ No newline at end of file From 11a2dcdc39741c572fc68af0c6de8bde9aa98219 Mon Sep 17 00:00:00 2001 From: Eric Mokaya Date: Wed, 22 Jan 2025 14:44:11 +0300 Subject: [PATCH 10/16] test: complete testing implementation --- actors/account/account_test.go | 44 +++--- actors/cron/cron_test.go | 50 +++++++ actors/datacap/allowance_test.go | 30 ++-- actors/datacap/burn_test.go | 11 +- actors/datacap/datacap_test.go | 31 +++- actors/datacap/granularity_test.go | 11 +- actors/datacap/mint_test.go | 6 +- actors/datacap/transfer_test.go | 6 +- actors/eam/create_test.go | 42 +++--- actors/evm/evm_test.go | 73 ++++++---- actors/init/int_test.go | 51 ++++--- actors/market/market_test.go | 137 ++++++++++++------ actors/miner/address_test.go | 51 +++---- actors/miner/balance_test.go | 11 +- actors/miner/miner_test.go | 71 ++++++--- actors/miner/sector_test.go | 45 ++++-- actors/multisig/multisig_test.go | 71 +++++---- actors/multisig/values_test.go | 56 +++---- actors/multisig/verifier_test.go | 5 +- actors/paymentChannel/paymentChannel_test.go | 29 +++- actors/power/power_test.go | 70 +++++---- actors/reward/reward_test.go | 40 +++-- .../verifiedRegistry/verifiedRegistry_test.go | 81 +++++++---- tools/testutil.go | 39 +++++ tools/version_mapping.go | 12 ++ 25 files changed, 707 insertions(+), 366 deletions(-) create mode 100644 actors/cron/cron_test.go diff --git a/actors/account/account_test.go b/actors/account/account_test.go index f6c2d89c..23d7f9aa 100644 --- a/actors/account/account_test.go +++ b/actors/account/account_test.go @@ -1,6 +1,8 @@ package account_test import ( + _ "embed" + "encoding/json" "os" "testing" @@ -13,6 +15,9 @@ import ( typesV2 "github.com/zondax/fil-parser/parser/v2/types" ) +//go:embed expected.json +var expectedData []byte +var expected map[string]any var lib *rosettaFilecoinLib.RosettaConstructionFilecoin func TestMain(m *testing.M) { @@ -21,48 +26,41 @@ func TestMain(m *testing.M) { if err != nil { panic(err) } + + err = json.Unmarshal(expectedData, &expected) + if err != nil { + panic(err) + } os.Exit(m.Run()) } func TestAuthenticateMessage(t *testing.T) { - tests := []struct { - name string - version string - url string - height int64 - expected map[string]any - }{} - + tests, err := tools.LoadTestData[map[string]any]("AuthenticateMessage", expected) + require.NoError(t, err) for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.height, tt.version) + t.Run(tt.Name, func(t *testing.T) { + computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.Height, tt.Version) require.NoError(t, err) for _, trace := range computeState.Trace { if trace.Msg == nil { continue } - result, err := account.AuthenticateMessage(tt.height, trace.Msg.Params, trace.MsgRct.Return) + result, err := account.AuthenticateMessage(tt.Height, trace.Msg.Params, trace.MsgRct.Return) require.NoError(t, err) - require.True(t, tools.CompareResult(result, tt.expected)) + require.True(t, tools.CompareResult(result, tt.Expected)) } - }) } } func TestPubkeyAddress(t *testing.T) { - tests := []struct { - name string - version string - url string - height int64 - expected map[string]any - }{} + tests, err := tools.LoadTestData[map[string]any]("PubkeyAddress", expected) + require.NoError(t, err) for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.height, tt.version) + t.Run(tt.Name, func(t *testing.T) { + computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.Height, tt.Version) require.NoError(t, err) for _, trace := range computeState.Trace { @@ -71,7 +69,7 @@ func TestPubkeyAddress(t *testing.T) { } result, err := account.PubkeyAddress(trace.Msg.Params, trace.MsgRct.Return) require.NoError(t, err) - require.True(t, tools.CompareResult(result, tt.expected)) + require.True(t, tools.CompareResult(result, tt.Expected)) } }) diff --git a/actors/cron/cron_test.go b/actors/cron/cron_test.go new file mode 100644 index 00000000..240aa9f9 --- /dev/null +++ b/actors/cron/cron_test.go @@ -0,0 +1,50 @@ +package cron_test + +import ( + _ "embed" + "encoding/json" + "testing" + + "github.com/stretchr/testify/require" + "github.com/zondax/fil-parser/actors/cron" + typesV2 "github.com/zondax/fil-parser/parser/v2/types" + "github.com/zondax/fil-parser/tools" +) + +//go:embed expected.json +var expectedData []byte +var expected map[string]any + +func TestMain(m *testing.M) { + if err := json.Unmarshal(expectedData, &expected); err != nil { + panic(err) + } + m.Run() +} + +type testFn func(height int64, raw []byte) (map[string]interface{}, error) + +func TestCronConstructor(t *testing.T) { + tests, err := tools.LoadTestData[map[string]any]("CronConstructor", expected) + require.NoError(t, err) + runTest(t, cron.CronConstructor, tests) +} + +func runTest(t *testing.T, fn testFn, tests []tools.TestCase[map[string]any]) { + for _, tt := range tests { + t.Run(tt.Name, func(t *testing.T) { + computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.Height, tt.Version) + require.NoError(t, err) + + for _, trace := range computeState.Trace { + if trace.Msg == nil { + continue + } + + result, err := fn(tt.Height, trace.Msg.Params) + require.NoError(t, err) + require.True(t, tools.CompareResult(result, tt.Expected)) + } + }) + } +} diff --git a/actors/datacap/allowance_test.go b/actors/datacap/allowance_test.go index ae0b8248..7d209b2c 100644 --- a/actors/datacap/allowance_test.go +++ b/actors/datacap/allowance_test.go @@ -12,51 +12,47 @@ import ( type testFn func(height int64, raw, rawReturn []byte) (map[string]interface{}, error) -type test struct { - name string - version string - url string - height int64 - expected map[string]any -} - func TestIncreaseAllowance(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("IncreaseAllowance", expected) + require.NoError(t, err) runTest(t, datacap.IncreaseAllowance, tests) } func TestDecreaseAllowance(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("DecreaseAllowance", expected) + require.NoError(t, err) runTest(t, datacap.DecreaseAllowance, tests) } func TestRevokeAllowance(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("RevokeAllowance", expected) + require.NoError(t, err) runTest(t, datacap.RevokeAllowance, tests) } func TestGetAllowance(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("GetAllowance", expected) + require.NoError(t, err) runTest(t, datacap.GetAllowance, tests) } -func runTest(t *testing.T, fn testFn, tests []test) { +func runTest(t *testing.T, fn testFn, tests []tools.TestCase[map[string]any]) { for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.height, tt.version) + t.Run(tt.Name, func(t *testing.T) { + computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.Height, tt.Version) require.NoError(t, err) for _, trace := range computeState.Trace { if trace.Msg == nil { continue } - result, err := fn(tt.height, trace.Msg.Params, trace.MsgRct.Return) + result, err := fn(tt.Height, trace.Msg.Params, trace.MsgRct.Return) require.NoError(t, err) - require.True(t, tools.CompareResult(result, tt.expected)) + require.True(t, tools.CompareResult(result, tt.Expected)) } }) } diff --git a/actors/datacap/burn_test.go b/actors/datacap/burn_test.go index 78356020..c03d0774 100644 --- a/actors/datacap/burn_test.go +++ b/actors/datacap/burn_test.go @@ -3,23 +3,28 @@ package datacap_test import ( "testing" + "github.com/stretchr/testify/require" "github.com/zondax/fil-parser/actors/datacap" + "github.com/zondax/fil-parser/tools" ) func TestBurnExported(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("BurnExported", expected) + require.NoError(t, err) runTest(t, datacap.BurnExported, tests) } func TestBurnFromExported(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("BurnFromExported", expected) + require.NoError(t, err) runTest(t, datacap.BurnFromExported, tests) } func TestDestroyExported(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("DestroyExported", expected) + require.NoError(t, err) runTest(t, datacap.DestroyExported, tests) } diff --git a/actors/datacap/datacap_test.go b/actors/datacap/datacap_test.go index 3f5686db..2d4b65e8 100644 --- a/actors/datacap/datacap_test.go +++ b/actors/datacap/datacap_test.go @@ -1,6 +1,9 @@ package datacap_test import ( + _ "embed" + "encoding/json" + "os" "testing" "github.com/stretchr/testify/require" @@ -9,28 +12,42 @@ import ( "github.com/zondax/fil-parser/tools" ) +//go:embed expected.json +var expectedData []byte +var expected map[string]any + +func TestMain(m *testing.M) { + if err := json.Unmarshal(expectedData, &expected); err != nil { + panic(err) + } + os.Exit(m.Run()) +} + func TestNameExported(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("NameExported", expected) + require.NoError(t, err) runDatacapTest(t, datacap.NameExported, tests) } func TestSymbolExported(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("SymbolExported", expected) + require.NoError(t, err) runDatacapTest(t, datacap.SymbolExported, tests) } func TestTotalSupplyExported(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("TotalSupplyExported", expected) + require.NoError(t, err) runDatacapTest(t, datacap.TotalSupplyExported, tests) } -func runDatacapTest(t *testing.T, fn func(rawReturn []byte) (map[string]interface{}, error), tests []test) { +func runDatacapTest(t *testing.T, fn func(rawReturn []byte) (map[string]interface{}, error), tests []tools.TestCase[map[string]any]) { for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.height, tt.version) + t.Run(tt.Name, func(t *testing.T) { + computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.Height, tt.Version) require.NoError(t, err) for _, trace := range computeState.Trace { @@ -39,7 +56,7 @@ func runDatacapTest(t *testing.T, fn func(rawReturn []byte) (map[string]interfac } result, err := fn(trace.MsgRct.Return) require.NoError(t, err) - require.True(t, tools.CompareResult(result, tt.expected)) + require.True(t, tools.CompareResult(result, tt.Expected)) } }) } diff --git a/actors/datacap/granularity_test.go b/actors/datacap/granularity_test.go index 0af6f080..b55c2e07 100644 --- a/actors/datacap/granularity_test.go +++ b/actors/datacap/granularity_test.go @@ -10,20 +10,21 @@ import ( ) func TestGranularityExported(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("GranularityExported", expected) + require.NoError(t, err) for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.height, tt.version) + t.Run(tt.Name, func(t *testing.T) { + computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.Height, tt.Version) require.NoError(t, err) for _, trace := range computeState.Trace { if trace.Msg == nil { continue } - result, err := datacap.GranularityExported(tt.height, trace.MsgRct.Return) + result, err := datacap.GranularityExported(tt.Height, trace.MsgRct.Return) require.NoError(t, err) - require.True(t, tools.CompareResult(result, tt.expected)) + require.True(t, tools.CompareResult(result, tt.Expected)) } }) } diff --git a/actors/datacap/mint_test.go b/actors/datacap/mint_test.go index 7fdf0bff..79cb223d 100644 --- a/actors/datacap/mint_test.go +++ b/actors/datacap/mint_test.go @@ -3,11 +3,15 @@ package datacap_test import ( "testing" + "github.com/stretchr/testify/require" "github.com/zondax/fil-parser/actors/datacap" + "github.com/zondax/fil-parser/tools" ) func TestMintExported(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("MintExported", expected) + require.NoError(t, err) + runTest(t, datacap.MintExported, tests) } diff --git a/actors/datacap/transfer_test.go b/actors/datacap/transfer_test.go index 89f50701..d1be5919 100644 --- a/actors/datacap/transfer_test.go +++ b/actors/datacap/transfer_test.go @@ -3,10 +3,14 @@ package datacap_test import ( "testing" + "github.com/stretchr/testify/require" "github.com/zondax/fil-parser/actors/datacap" + "github.com/zondax/fil-parser/tools" ) func TestTransferExported(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("TransferExported", expected) + require.NoError(t, err) + runTest(t, datacap.TransferExported, tests) } diff --git a/actors/eam/create_test.go b/actors/eam/create_test.go index 983ef272..f7915c1a 100644 --- a/actors/eam/create_test.go +++ b/actors/eam/create_test.go @@ -1,6 +1,9 @@ package eam_test import ( + _ "embed" + "encoding/json" + "os" "testing" "github.com/ipfs/go-cid" @@ -11,49 +14,54 @@ import ( "github.com/zondax/fil-parser/types" ) -type testFn func(height int64, raw, rawReturn []byte, msgCid cid.Cid) (map[string]interface{}, *types.AddressInfo, error) +//go:embed expected.json +var expectedData []byte +var expected map[string]any -type test struct { - name string - version string - url string - height int64 - expected map[string]any - addr *types.AddressInfo +func TestMain(m *testing.M) { + if err := json.Unmarshal(expectedData, &expected); err != nil { + panic(err) + } + os.Exit(m.Run()) } +type testFn func(height int64, raw, rawReturn []byte, msgCid cid.Cid) (map[string]interface{}, *types.AddressInfo, error) + func TestParseCreateExternal(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("CreateExternalExported", expected) + require.NoError(t, err) runTest(t, eam.ParseCreateExternal, tests) } func TestParseCreate(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("CreateExported", expected) + require.NoError(t, err) runTest(t, eam.ParseCreate, tests) } func TestParseCreate2(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("Create2Exported", expected) + require.NoError(t, err) runTest(t, eam.ParseCreate2, tests) } -func runTest(t *testing.T, fn testFn, tests []test) { +func runTest(t *testing.T, fn testFn, tests []tools.TestCase[map[string]any]) { for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.height, tt.version) + t.Run(tt.Name, func(t *testing.T) { + computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.Height, tt.Version) require.NoError(t, err) for _, trace := range computeState.Trace { if trace.Msg == nil { continue } - result, addrInfo, err := fn(tt.height, trace.Msg.Params, trace.MsgRct.Return, trace.Msg.Cid()) + result, addrInfo, err := fn(tt.Height, trace.Msg.Params, trace.MsgRct.Return, trace.Msg.Cid()) require.NoError(t, err) - require.True(t, tools.CompareResult(result, tt.expected)) - require.Equal(t, addrInfo, tt.addr) + require.True(t, tools.CompareResult(result, tt.Expected)) + require.Equal(t, addrInfo, tt.Address) } }) } diff --git a/actors/evm/evm_test.go b/actors/evm/evm_test.go index 41d01085..91ce365b 100644 --- a/actors/evm/evm_test.go +++ b/actors/evm/evm_test.go @@ -1,6 +1,9 @@ package evm_test import ( + _ "embed" + "encoding/json" + "os" "testing" "github.com/stretchr/testify/require" @@ -10,64 +13,75 @@ import ( typesV2 "github.com/zondax/fil-parser/parser/v2/types" ) -type testFn func(height int64, raw []byte) (map[string]interface{}, error) +//go:embed expected.json +var expectedData []byte +var expected map[string]any -type test struct { - name string - version string - height int64 - expected map[string]any +func TestMain(m *testing.M) { + if err := json.Unmarshal(expectedData, &expected); err != nil { + panic(err) + } + os.Exit(m.Run()) } +type testFn func(height int64, raw []byte) (map[string]interface{}, error) + func TestResurrect(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("Resurrect", expected) + require.NoError(t, err) runTest(t, evm.Resurrect, tests) } func TestGetByteCode(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("GetByteCode", expected) + require.NoError(t, err) runTest(t, evm.GetByteCode, tests) } func TestGetByteCodeHash(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("GetByteCodeHash", expected) + require.NoError(t, err) runTest(t, evm.GetByteCodeHash, tests) } func TestEVMConstructor(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("EVMConstructor", expected) + require.NoError(t, err) runTest(t, evm.EVMConstructor, tests) } func TestGetStorageAt(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("GetStorageAt", expected) + require.NoError(t, err) + for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.height, tt.version) + t.Run(tt.Name, func(t *testing.T) { + computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.Height, tt.Version) require.NoError(t, err) for _, trace := range computeState.Trace { if trace.Msg == nil { continue } - result, err := evm.GetStorageAt(tt.height, trace.Msg.Params, trace.MsgRct.Return) + result, err := evm.GetStorageAt(tt.Height, trace.Msg.Params, trace.MsgRct.Return) require.NoError(t, err) - require.True(t, tools.CompareResult(result, tt.expected)) + require.True(t, tools.CompareResult(result, tt.Expected)) } }) } } func TestInvokeContract(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("InvokeContract", expected) + require.NoError(t, err) for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.height, tt.version) + t.Run(tt.Name, func(t *testing.T) { + computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.Height, tt.Version) require.NoError(t, err) for _, trace := range computeState.Trace { @@ -76,45 +90,46 @@ func TestInvokeContract(t *testing.T) { } result, err := evm.InvokeContract(trace.Msg.Params, trace.MsgRct.Return) require.NoError(t, err) - require.True(t, tools.CompareResult(result, tt.expected)) + require.True(t, tools.CompareResult(result, tt.Expected)) } }) } } func TestInvokeContractDelegate(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("InvokeContractDelegate", expected) + require.NoError(t, err) for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.height, tt.version) + t.Run(tt.Name, func(t *testing.T) { + computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.Height, tt.Version) require.NoError(t, err) for _, trace := range computeState.Trace { if trace.Msg == nil { continue } - result, err := evm.InvokeContractDelegate(tt.height, trace.Msg.Params, trace.MsgRct.Return) + result, err := evm.InvokeContractDelegate(tt.Height, trace.Msg.Params, trace.MsgRct.Return) require.NoError(t, err) - require.True(t, tools.CompareResult(result, tt.expected)) + require.True(t, tools.CompareResult(result, tt.Expected)) } }) } } -func runTest(t *testing.T, fn testFn, tests []test) { +func runTest(t *testing.T, fn testFn, tests []tools.TestCase[map[string]any]) { for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.height, tt.version) + t.Run(tt.Name, func(t *testing.T) { + computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.Height, tt.Version) require.NoError(t, err) for _, trace := range computeState.Trace { if trace.Msg == nil { continue } - result, err := fn(tt.height, trace.Msg.Params) + result, err := fn(tt.Height, trace.Msg.Params) require.NoError(t, err) - require.True(t, tools.CompareResult(result, tt.expected)) + require.True(t, tools.CompareResult(result, tt.Expected)) } }) } diff --git a/actors/init/int_test.go b/actors/init/int_test.go index 648972ff..b8af1136 100644 --- a/actors/init/int_test.go +++ b/actors/init/int_test.go @@ -1,6 +1,9 @@ package init_test import ( + _ "embed" + "encoding/json" + "os" "testing" "github.com/stretchr/testify/require" @@ -12,34 +15,40 @@ import ( typesV2 "github.com/zondax/fil-parser/parser/v2/types" ) -type testFn func(height int64, msg *parser.LotusMessage, raw []byte) (map[string]interface{}, *types.AddressInfo, error) +//go:embed expected.json +var expectedData []byte +var expected map[string]any -type test struct { - name string - version string - url string - height int64 - expected map[string]any - address *types.AddressInfo +func TestMain(m *testing.M) { + if err := json.Unmarshal(expectedData, &expected); err != nil { + panic(err) + } + os.Exit(m.Run()) } +type testFn func(height int64, msg *parser.LotusMessage, raw []byte) (map[string]interface{}, *types.AddressInfo, error) + func TestParseExec(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("ParseExec", expected) + require.NoError(t, err) runTest(t, initActor.ParseExec, tests) } func TestParseExec4(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("ParseExec4", expected) + require.NoError(t, err) runTest(t, initActor.ParseExec4, tests) } func TestInitConstructor(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("InitConstructor", expected) + require.NoError(t, err) + for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.height, tt.version) + t.Run(tt.Name, func(t *testing.T) { + computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.Height, tt.Version) require.NoError(t, err) for _, trace := range computeState.Trace { @@ -47,19 +56,19 @@ func TestInitConstructor(t *testing.T) { continue } - result, err := initActor.InitConstructor(tt.height, trace.Msg.Params) + result, err := initActor.InitConstructor(tt.Height, trace.Msg.Params) require.NoError(t, err) - require.True(t, tools.CompareResult(result, tt.expected)) + require.True(t, tools.CompareResult(result, tt.Expected)) } }) } } -func runTest(t *testing.T, fn testFn, tests []test) { +func runTest(t *testing.T, fn testFn, tests []tools.TestCase[map[string]any]) { for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.height, tt.version) + t.Run(tt.Name, func(t *testing.T) { + computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.Height, tt.Version) require.NoError(t, err) for _, trace := range computeState.Trace { @@ -71,10 +80,10 @@ func runTest(t *testing.T, fn testFn, tests []test) { From: trace.Msg.From, Method: trace.Msg.Method, } - result, address, err := fn(tt.height, lotusMsg, trace.Msg.Params) + result, address, err := fn(tt.Height, lotusMsg, trace.Msg.Params) require.NoError(t, err) - require.True(t, tools.CompareResult(result, tt.expected)) - require.Equal(t, address, tt.address) + require.True(t, tools.CompareResult(result, tt.Expected)) + require.Equal(t, address, tt.Address) } }) } diff --git a/actors/market/market_test.go b/actors/market/market_test.go index 87f22209..5fbc1d55 100644 --- a/actors/market/market_test.go +++ b/actors/market/market_test.go @@ -1,6 +1,9 @@ package market_test import ( + _ "embed" + "encoding/json" + "os" "testing" "github.com/stretchr/testify/require" @@ -10,112 +13,152 @@ import ( typesV2 "github.com/zondax/fil-parser/parser/v2/types" ) -type testFn func(height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) +//go:embed expected.json +var expectedData []byte +var expected map[string]any -type test struct { - name string - version string - url string - height int64 - expected map[string]any +func TestMain(m *testing.M) { + if err := json.Unmarshal(expectedData, &expected); err != nil { + panic(err) + } + os.Exit(m.Run()) } +type testFn func(height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) + func TestPublishStorageDeals(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("PublishStorageDealsParams", expected) + require.NoError(t, err) runTest(t, market.PublishStorageDealsParams, tests) } func TestVerifyDealsForActivation(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("VerifyDealsForActivationParams", expected) + require.NoError(t, err) + runTest(t, market.VerifyDealsForActivationParams, tests) } func TestActivateDeals(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("ActivateDealsParams", expected) + require.NoError(t, err) + runTest(t, market.ActivateDealsParams, tests) } func TestComputeDataCommitment(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("ComputeDataCommitmentParams", expected) + require.NoError(t, err) + runTest(t, market.ComputeDataCommitmentParams, tests) } func TestGetBalance(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("GetBalanceParams", expected) + require.NoError(t, err) + runTest(t, market.GetBalanceParams, tests) } func TestGetDealDataCommitment(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("GetDealDataCommitmentParams", expected) + require.NoError(t, err) + runTest(t, market.GetDealDataCommitmentParams, tests) } func TestGetDealClient(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("GetDealClientParams", expected) + require.NoError(t, err) + runTest(t, market.GetDealClientParams, tests) } func TestGetDealProvider(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("GetDealProviderParams", expected) + require.NoError(t, err) + runTest(t, market.GetDealProviderParams, tests) } func TestGetDealLabel(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("GetDealLabelParams", expected) + require.NoError(t, err) + runTest(t, market.GetDealLabelParams, tests) } func TestGetDealTerm(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("GetDealTermParams", expected) + require.NoError(t, err) + runTest(t, market.GetDealTermParams, tests) } func TestGetDealTotalPrice(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("GetDealTotalPriceParams", expected) + require.NoError(t, err) + runTest(t, market.GetDealTotalPriceParams, tests) } func TestGetDealClientCollateral(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("GetDealClientCollateralParams", expected) + require.NoError(t, err) + runTest(t, market.GetDealClientCollateralParams, tests) } func TestGetDealProviderCollateral(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("GetDealProviderCollateralParams", expected) + require.NoError(t, err) + runTest(t, market.GetDealProviderCollateralParams, tests) } func TestGetDealVerified(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("GetDealVerifiedParams", expected) + require.NoError(t, err) + runTest(t, market.GetDealVerifiedParams, tests) } func TestGetDealActivation(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("GetDealActivationParams", expected) + require.NoError(t, err) + runTest(t, market.GetDealActivationParams, tests) } func TestDealProviderCollateral(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("GetDealProviderCollateralParams", expected) + require.NoError(t, err) + runTest(t, market.GetDealProviderCollateralParams, tests) } func TestGetDealVerifiedParams(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("GetDealVerifiedParams", expected) + require.NoError(t, err) + runTest(t, market.GetDealVerifiedParams, tests) } func TestGetDealActivationParams(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("GetDealActivationParams", expected) + require.NoError(t, err) + runTest(t, market.GetDealActivationParams, tests) } func TestOnMinerSectorsTerminate(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("OnMinerSectorsTerminateParams", expected) + require.NoError(t, err) + for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.height, tt.version) + t.Run(tt.Name, func(t *testing.T) { + computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.Height, tt.Version) require.NoError(t, err) for _, trace := range computeState.Trace { @@ -123,19 +166,21 @@ func TestOnMinerSectorsTerminate(t *testing.T) { continue } - result, err := market.OnMinerSectorsTerminateParams(tt.height, trace.Msg.Params) + result, err := market.OnMinerSectorsTerminateParams(tt.Height, trace.Msg.Params) require.NoError(t, err) - require.True(t, tools.CompareResult(result, tt.expected)) + require.True(t, tools.CompareResult(result, tt.Expected)) } }) } } func TestParseAddBalance(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("ParseAddBalance", expected) + require.NoError(t, err) + for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.height, tt.version) + t.Run(tt.Name, func(t *testing.T) { + computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.Height, tt.Version) require.NoError(t, err) for _, trace := range computeState.Trace { @@ -143,19 +188,21 @@ func TestParseAddBalance(t *testing.T) { continue } - result, err := market.ParseAddBalance(tt.height, trace.Msg.Params) + result, err := market.ParseAddBalance(tt.Height, trace.Msg.Params) require.NoError(t, err) - require.True(t, tools.CompareResult(result, tt.expected)) + require.True(t, tools.CompareResult(result, tt.Expected)) } }) } } func TestParseWithdrawBalance(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("ParseWithdrawBalance", expected) + require.NoError(t, err) + for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.height, tt.version) + t.Run(tt.Name, func(t *testing.T) { + computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.Height, tt.Version) require.NoError(t, err) for _, trace := range computeState.Trace { @@ -163,18 +210,18 @@ func TestParseWithdrawBalance(t *testing.T) { continue } - result, err := market.ParseWithdrawBalance(tt.height, trace.Msg.Params) + result, err := market.ParseWithdrawBalance(tt.Height, trace.Msg.Params) require.NoError(t, err) - require.True(t, tools.CompareResult(result, tt.expected)) + require.True(t, tools.CompareResult(result, tt.Expected)) } }) } } -func runTest(t *testing.T, fn testFn, tests []test) { +func runTest(t *testing.T, fn testFn, tests []tools.TestCase[map[string]any]) { for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.height, tt.version) + t.Run(tt.Name, func(t *testing.T) { + computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.Height, tt.Version) require.NoError(t, err) for _, trace := range computeState.Trace { @@ -182,9 +229,9 @@ func runTest(t *testing.T, fn testFn, tests []test) { continue } - result, err := fn(tt.height, trace.Msg.Params, trace.MsgRct.Return) + result, err := fn(tt.Height, trace.Msg.Params, trace.MsgRct.Return) require.NoError(t, err) - require.True(t, tools.CompareResult(result, tt.expected)) + require.True(t, tools.CompareResult(result, tt.Expected)) } }) } diff --git a/actors/miner/address_test.go b/actors/miner/address_test.go index c7a1c00d..f79210c1 100644 --- a/actors/miner/address_test.go +++ b/actors/miner/address_test.go @@ -11,54 +11,55 @@ import ( type testFn func(height int64, rawReturn []byte) (map[string]interface{}, error) -type test struct { - name string - version string - url string - height int64 - expected map[string]any -} - func TestChangeMultiaddrs(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("ChangeMultiaddrs", expectedData) + require.NoError(t, err) runTest(t, miner.ChangeMultiaddrs, tests) } func TestChangePeerID(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("ChangePeerID", expectedData) + require.NoError(t, err) runTest(t, miner.ChangePeerID, tests) } func TestChangeWorkerAddress(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("ChangeWorkerAddress", expectedData) + require.NoError(t, err) runTest(t, miner.ChangeWorkerAddress, tests) } func TestChangeOwnerAddress(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("ChangeOwnerAddress", expectedData) + require.NoError(t, err) runTest(t, miner.ChangeOwnerAddress, tests) } func TestGetOwner(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("GetOwner", expectedData) + require.NoError(t, err) runTest(t, miner.GetOwner, tests) } func TestGetPeerID(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("GetPeerID", expectedData) + require.NoError(t, err) runTest(t, miner.GetPeerID, tests) } func TestGetMultiaddrs(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("GetMultiaddrs", expectedData) + require.NoError(t, err) runTest(t, miner.GetMultiaddrs, tests) } func TestIsControllingAddressExported(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("IsControllingAddressExported", expectedData) + require.NoError(t, err) + for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.height, tt.version) + t.Run(tt.Name, func(t *testing.T) { + computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.Height, tt.Version) require.NoError(t, err) for _, trace := range computeState.Trace { @@ -66,19 +67,19 @@ func TestIsControllingAddressExported(t *testing.T) { continue } - result, err := miner.IsControllingAddressExported(tt.height, trace.Msg.Params, trace.MsgRct.Return) + result, err := miner.IsControllingAddressExported(tt.Height, trace.Msg.Params, trace.MsgRct.Return) require.NoError(t, err) - require.True(t, tools.CompareResult(result, tt.expected)) + require.True(t, tools.CompareResult(result, tt.Expected)) } }) } } -func runTest(t *testing.T, fn testFn, tests []test) { +func runTest(t *testing.T, fn testFn, tests []tools.TestCase[map[string]any]) { for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.height, tt.version) + t.Run(tt.Name, func(t *testing.T) { + computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.Height, tt.Version) require.NoError(t, err) for _, trace := range computeState.Trace { @@ -86,9 +87,9 @@ func runTest(t *testing.T, fn testFn, tests []test) { continue } - result, err := fn(tt.height, trace.MsgRct.Return) + result, err := fn(tt.Height, trace.MsgRct.Return) require.NoError(t, err) - require.True(t, tools.CompareResult(result, tt.expected)) + require.True(t, tools.CompareResult(result, tt.Expected)) } }) diff --git a/actors/miner/balance_test.go b/actors/miner/balance_test.go index 81efdd9a..cb98218a 100644 --- a/actors/miner/balance_test.go +++ b/actors/miner/balance_test.go @@ -3,20 +3,25 @@ package miner_test import ( "testing" + "github.com/stretchr/testify/require" "github.com/zondax/fil-parser/actors/miner" + "github.com/zondax/fil-parser/tools" ) func TestGetAvailableBalance(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("GetAvailableBalance", expectedData) + require.NoError(t, err) runTest(t, miner.GetAvailableBalance, tests) } func TestGetVestingFunds(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("GetVestingFunds", expectedData) + require.NoError(t, err) runTest(t, miner.GetVestingFunds, tests) } func TestParseWithdrawBalance(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("ParseWithdrawBalance", expectedData) + require.NoError(t, err) runTest(t, miner.ParseWithdrawBalance, tests) } diff --git a/actors/miner/miner_test.go b/actors/miner/miner_test.go index 19eb69ee..6956a8e9 100644 --- a/actors/miner/miner_test.go +++ b/actors/miner/miner_test.go @@ -1,6 +1,9 @@ package miner_test import ( + _ "embed" + "encoding/json" + "os" "testing" "github.com/stretchr/testify/require" @@ -9,66 +12,90 @@ import ( "github.com/zondax/fil-parser/tools" ) +//go:embed expected.json +var expected []byte +var expectedData map[string]any + +func TestMain(m *testing.M) { + if err := json.Unmarshal(expected, &expectedData); err != nil { + panic(err) + } + os.Exit(m.Run()) +} + func TestDeclareFaults(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("DeclareFaults", expectedData) + require.NoError(t, err) runTest(t, miner.DeclareFaults, tests) } func TestDeclareFaultsRecovered(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("DeclareFaultsRecovered", expectedData) + require.NoError(t, err) runTest(t, miner.DeclareFaultsRecovered, tests) } func TestProveReplicaUpdates(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("ProveReplicaUpdates", expectedData) + require.NoError(t, err) runTest(t, miner.ProveReplicaUpdates, tests) } func TestPreCommitSectorBatch2(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("PreCommitSectorBatch2", expectedData) + require.NoError(t, err) runTest(t, miner.PreCommitSectorBatch2, tests) } func TestProveCommitAggregate(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("ProveCommitAggregate", expectedData) + require.NoError(t, err) runTest(t, miner.ProveCommitAggregate, tests) } func TestDisputeWindowedPoSt(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("DisputeWindowedPoSt", expectedData) + require.NoError(t, err) runTest(t, miner.DisputeWindowedPoSt, tests) } func TestReportConsensusFault(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("ReportConsensusFault", expectedData) + require.NoError(t, err) runTest(t, miner.ReportConsensusFault, tests) } func TestChangeBeneficiary(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("ChangeBeneficiary", expectedData) + require.NoError(t, err) runTest(t, miner.ChangeBeneficiary, tests) } func TestMinerConstructor(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("MinerConstructor", expectedData) + require.NoError(t, err) runTest(t, miner.MinerConstructor, tests) } func TestApplyRewards(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("ApplyRewards", expectedData) + require.NoError(t, err) runTest(t, miner.ApplyRewards, tests) } func TestOnDeferredCronEvent(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("OnDeferredCronEvent", expectedData) + require.NoError(t, err) runTest(t, miner.OnDeferredCronEvent, tests) } func TestTerminateSectors(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("TerminateSectors", expectedData) + require.NoError(t, err) + for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.height, tt.version) + t.Run(tt.Name, func(t *testing.T) { + computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.Height, tt.Version) require.NoError(t, err) for _, trace := range computeState.Trace { @@ -76,9 +103,9 @@ func TestTerminateSectors(t *testing.T) { continue } - result, err := miner.TerminateSectors(tt.height, trace.Msg.Params, trace.MsgRct.Return) + result, err := miner.TerminateSectors(tt.Height, trace.Msg.Params, trace.MsgRct.Return) require.NoError(t, err) - require.True(t, tools.CompareResult(result, tt.expected)) + require.True(t, tools.CompareResult(result, tt.Expected)) } }) @@ -86,10 +113,12 @@ func TestTerminateSectors(t *testing.T) { } func TestProveReplicaUpdates2(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("ProveReplicaUpdates2", expectedData) + require.NoError(t, err) + for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.height, tt.version) + t.Run(tt.Name, func(t *testing.T) { + computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.Height, tt.Version) require.NoError(t, err) for _, trace := range computeState.Trace { @@ -97,9 +126,9 @@ func TestProveReplicaUpdates2(t *testing.T) { continue } - result, err := miner.ProveReplicaUpdates2(tt.height, trace.Msg.Params, trace.MsgRct.Return) + result, err := miner.ProveReplicaUpdates2(tt.Height, trace.Msg.Params, trace.MsgRct.Return) require.NoError(t, err) - require.True(t, tools.CompareResult(result, tt.expected)) + require.True(t, tools.CompareResult(result, tt.Expected)) } }) diff --git a/actors/miner/sector_test.go b/actors/miner/sector_test.go index 8be0c9cb..cf9752fe 100644 --- a/actors/miner/sector_test.go +++ b/actors/miner/sector_test.go @@ -10,65 +10,78 @@ import ( ) func TestExtendSectorExpiration2(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("ExtendSectorExpiration2", expectedData) + require.NoError(t, err) runTest(t, miner.ExtendSectorExpiration2, tests) } func TestPreCommitSector(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("PreCommitSector", expectedData) + require.NoError(t, err) runTest(t, miner.PreCommitSector, tests) } func TestProveCommitSector(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("ProveCommitSector", expectedData) + require.NoError(t, err) runTest(t, miner.ProveCommitSector, tests) } func TestSubmitWindowedPoSt(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("SubmitWindowedPoSt", expectedData) + require.NoError(t, err) runTest(t, miner.SubmitWindowedPoSt, tests) } func TestConfirmSectorProofsValid(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("ConfirmSectorProofsValid", expectedData) + require.NoError(t, err) runTest(t, miner.ConfirmSectorProofsValid, tests) } func TestCheckSectorProven(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("CheckSectorProven", expectedData) + require.NoError(t, err) runTest(t, miner.CheckSectorProven, tests) } func TestExtendSectorExpiration(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("ExtendSectorExpiration", expectedData) + require.NoError(t, err) runTest(t, miner.ExtendSectorExpiration, tests) } func TestCompactSectorNumbers(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("CompactSectorNumbers", expectedData) + require.NoError(t, err) runTest(t, miner.CompactSectorNumbers, tests) } func TestCompactPartitions(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("CompactPartitions", expectedData) + require.NoError(t, err) runTest(t, miner.CompactPartitions, tests) } func TestPreCommitSectorBatch(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("PreCommitSectorBatch", expectedData) + require.NoError(t, err) runTest(t, miner.PreCommitSectorBatch, tests) } func TestGetSectorSize(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("GetSectorSize", expectedData) + require.NoError(t, err) runTest(t, miner.GetSectorSize, tests) } func TestProveCommitSectors3(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("ProveCommitSectors3", expectedData) + require.NoError(t, err) + for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.height, tt.version) + t.Run(tt.Name, func(t *testing.T) { + computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.Height, tt.Version) require.NoError(t, err) for _, trace := range computeState.Trace { @@ -76,9 +89,9 @@ func TestProveCommitSectors3(t *testing.T) { continue } - result, err := miner.ProveCommitSectors3(tt.height, trace.Msg.Params, trace.MsgRct.Return) + result, err := miner.ProveCommitSectors3(tt.Height, trace.Msg.Params, trace.MsgRct.Return) require.NoError(t, err) - require.True(t, tools.CompareResult(result, tt.expected)) + require.True(t, tools.CompareResult(result, tt.Expected)) } }) diff --git a/actors/multisig/multisig_test.go b/actors/multisig/multisig_test.go index 9da818bd..9add4edd 100644 --- a/actors/multisig/multisig_test.go +++ b/actors/multisig/multisig_test.go @@ -1,6 +1,8 @@ package multisig_test import ( + _ "embed" + "encoding/json" "testing" filTypes "github.com/filecoin-project/lotus/chain/types" @@ -12,50 +14,62 @@ import ( typesV2 "github.com/zondax/fil-parser/parser/v2/types" ) -type testFn func(msg *parser.LotusMessage, height int64, key filTypes.TipSetKey, rawReturn []byte, parser multisig.ParseFn) (map[string]interface{}, error) -type tests struct { - name string - height int64 - version string - expected map[string]interface{} - tipsetKey filTypes.TipSetKey +//go:embed expected.json +var expectedData []byte +var expected map[string]any + +func TestMain(m *testing.M) { + if err := json.Unmarshal(expectedData, &expected); err != nil { + panic(err) + } + m.Run() } +type testFn func(msg *parser.LotusMessage, height int64, key filTypes.TipSetKey, rawReturn []byte, parser multisig.ParseFn) (map[string]interface{}, error) + func TestApprove(t *testing.T) { - tests := []tests{} + tests, err := tools.LoadTestData[map[string]any]("Approve", expected) + require.NoError(t, err) runTest(t, multisig.Approve, tests) } func TestCancel(t *testing.T) { - tests := []tests{} + tests, err := tools.LoadTestData[map[string]any]("Cancel", expected) + require.NoError(t, err) runTest(t, multisig.Cancel, tests) } func TestRemoveSigner(t *testing.T) { - tests := []tests{} + tests, err := tools.LoadTestData[map[string]any]("RemoveSigner", expected) + require.NoError(t, err) runTest(t, multisig.RemoveSigner, tests) } func TestChangeNumApprovalsThreshold(t *testing.T) { - tests := []tests{} + tests, err := tools.LoadTestData[map[string]any]("ChangeNumApprovalsThreshold", expected) + require.NoError(t, err) runTest(t, multisig.ChangeNumApprovalsThreshold, tests) } func TestLockBalance(t *testing.T) { - tests := []tests{} + tests, err := tools.LoadTestData[map[string]any]("LockBalance", expected) + require.NoError(t, err) runTest(t, multisig.LockBalance, tests) } func TestUniversalReceiverHook(t *testing.T) { - tests := []tests{} + tests, err := tools.LoadTestData[map[string]any]("UniversalReceiverHook", expected) + require.NoError(t, err) runTest(t, multisig.UniversalReceiverHook, tests) } func TestMsigConstructor(t *testing.T) { - tests := []tests{} + tests, err := tools.LoadTestData[map[string]any]("MsigConstructor", expected) + require.NoError(t, err) + for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.height, tt.version) + t.Run(tt.Name, func(t *testing.T) { + computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.Height, tt.Version) require.NoError(t, err) for _, trace := range computeState.Trace { @@ -63,19 +77,20 @@ func TestMsigConstructor(t *testing.T) { continue } - result, err := multisig.MsigConstructor(tt.height, trace.MsgRct.Return) + result, err := multisig.MsigConstructor(tt.Height, trace.MsgRct.Return) require.NoError(t, err) - require.True(t, tools.CompareResult(result, tt.expected)) + require.True(t, tools.CompareResult(result, tt.Expected)) } }) } } func TestMsigParams(t *testing.T) { - tests := []tests{} + tests, err := tools.LoadTestData[map[string]any]("MsigParams", expected) + require.NoError(t, err) for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.height, tt.version) + t.Run(tt.Name, func(t *testing.T) { + computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.Height, tt.Version) require.NoError(t, err) for _, trace := range computeState.Trace { @@ -88,21 +103,21 @@ func TestMsigParams(t *testing.T) { From: trace.Msg.From, Method: trace.Msg.Method, } - result, err := multisig.MsigParams(lotusMsg, tt.height, tt.tipsetKey, func(*parser.LotusMessage, int64, filTypes.TipSetKey) (string, error) { + result, err := multisig.MsigParams(lotusMsg, tt.Height, tt.TipsetKey, func(*parser.LotusMessage, int64, filTypes.TipSetKey) (string, error) { return "", nil }) require.NoError(t, err) - require.True(t, tools.CompareResult(result, tt.expected)) + require.True(t, tools.CompareResult(result, tt.Expected)) } }) } } -func runTest(t *testing.T, fn testFn, tests []tests) { +func runTest(t *testing.T, fn testFn, tests []tools.TestCase[map[string]any]) { for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.height, tt.version) + t.Run(tt.Name, func(t *testing.T) { + computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.Height, tt.Version) require.NoError(t, err) for _, trace := range computeState.Trace { @@ -115,11 +130,11 @@ func runTest(t *testing.T, fn testFn, tests []tests) { From: trace.Msg.From, Method: trace.Msg.Method, } - result, err := fn(lotusMsg, tt.height, tt.tipsetKey, trace.MsgRct.Return, func(*parser.LotusMessage, int64, filTypes.TipSetKey) (string, error) { + result, err := fn(lotusMsg, tt.Height, tt.TipsetKey, trace.MsgRct.Return, func(*parser.LotusMessage, int64, filTypes.TipSetKey) (string, error) { return "", nil }) require.NoError(t, err) - require.True(t, tools.CompareResult(result, tt.expected)) + require.True(t, tools.CompareResult(result, tt.Expected)) } }) diff --git a/actors/multisig/values_test.go b/actors/multisig/values_test.go index d58284fa..dbf19595 100644 --- a/actors/multisig/values_test.go +++ b/actors/multisig/values_test.go @@ -12,81 +12,87 @@ import ( type valueTestFn func(height int64, txMetadata string) (interface{}, error) -type test struct { - name string - height int64 - version string - expected interface{} -} - func TestChangeOwnerAddressValue(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("ChangeOwnerAddressValue", expected) + require.NoError(t, err) runValueTest(t, multisig.ChangeOwnerAddressValue, tests) } func TestParseWithdrawBalanceValue(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("ParseWithdrawBalanceValue", expected) + require.NoError(t, err) runValueTest(t, multisig.ParseWithdrawBalanceValue, tests) } func TestParseInvokeContractValue(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("ParseInvokeContractValue", expected) + require.NoError(t, err) runValueTest(t, multisig.ParseInvokeContractValue, tests) } func TestParseAddSignerValue(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("ParseAddSignerValue", expected) + require.NoError(t, err) runValueTest(t, multisig.ParseAddSignerValue, tests) } func TestParseApproveValue(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("ParseApproveValue", expected) + require.NoError(t, err) runValueTest(t, multisig.ParseApproveValue, tests) } func TestParseCancelValue(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("ParseCancelValue", expected) + require.NoError(t, err) runValueTest(t, multisig.ParseCancelValue, tests) } func TestChangeNumApprovalsThresholdValue(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("ChangeNumApprovalsThresholdValue", expected) + require.NoError(t, err) runValueTest(t, multisig.ChangeNumApprovalsThresholdValue, tests) } func TestParseConstructorValue(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("ParseConstructorValue", expected) + require.NoError(t, err) runValueTest(t, multisig.ParseConstructorValue, tests) } func TestParseLockBalanceValue(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("ParseLockBalanceValue", expected) + require.NoError(t, err) runValueTest(t, multisig.ParseLockBalanceValue, tests) } func TestParseRemoveSignerValue(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("ParseRemoveSignerValue", expected) + require.NoError(t, err) runValueTest(t, multisig.ParseRemoveSignerValue, tests) } func TestParseSendValue(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("ParseSendValue", expected) + require.NoError(t, err) runValueTest(t, multisig.ParseSendValue, tests) } func TestParseSwapSignerValue(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("ParseSwapSignerValue", expected) + require.NoError(t, err) runValueTest(t, multisig.ParseSwapSignerValue, tests) } func TestParseUniversalReceiverHookValue(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("ParseUniversalReceiverHookValue", expected) + require.NoError(t, err) runValueTest(t, multisig.ParseUniversalReceiverHookValue, tests) } -func runValueTest(t *testing.T, fn valueTestFn, tests []test) { +func runValueTest(t *testing.T, fn valueTestFn, tests []tools.TestCase[map[string]any]) { for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.height, tt.version) + t.Run(tt.Name, func(t *testing.T) { + computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.Height, tt.Version) require.NoError(t, err) for _, trace := range computeState.Trace { @@ -95,9 +101,9 @@ func runValueTest(t *testing.T, fn valueTestFn, tests []test) { } // TODO: parse whole multisig tx first before calling this function - result, err := fn(tt.height, string(trace.Msg.Params)) + result, err := fn(tt.Height, string(trace.Msg.Params)) require.NoError(t, err) - require.True(t, reflect.DeepEqual(result, tt.expected)) + require.True(t, reflect.DeepEqual(result, tt.Expected)) } }) } diff --git a/actors/multisig/verifier_test.go b/actors/multisig/verifier_test.go index cf12528a..790c4e5c 100644 --- a/actors/multisig/verifier_test.go +++ b/actors/multisig/verifier_test.go @@ -3,10 +3,13 @@ package multisig_test import ( "testing" + "github.com/stretchr/testify/require" "github.com/zondax/fil-parser/actors/multisig" + "github.com/zondax/fil-parser/tools" ) func TestAddVerifierValue(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("AddVerifierValue", expected) + require.NoError(t, err) runValueTest(t, multisig.AddVerifierValue, tests) } diff --git a/actors/paymentChannel/paymentChannel_test.go b/actors/paymentChannel/paymentChannel_test.go index 65a785fa..e1d8dc63 100644 --- a/actors/paymentChannel/paymentChannel_test.go +++ b/actors/paymentChannel/paymentChannel_test.go @@ -1,6 +1,8 @@ package paymentchannel_test import ( + _ "embed" + "encoding/json" "testing" "github.com/stretchr/testify/require" @@ -9,6 +11,17 @@ import ( "github.com/zondax/fil-parser/tools" ) +//go:embed expected.json +var expectedData []byte +var expected map[string]any + +func TestMain(m *testing.M) { + if err := json.Unmarshal(expectedData, &expected); err != nil { + panic(err) + } + m.Run() +} + type testFn func(height int64, raw []byte) (map[string]interface{}, error) type test struct { name string @@ -18,19 +31,21 @@ type test struct { } func TestPaymentChannelConstructor(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("PaymentChannelConstructor", expected) + require.NoError(t, err) runTest(t, paymentchannel.PaymentChannelConstructor, tests) } func TestUpdateChannelState(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("UpdateChannelState", expected) + require.NoError(t, err) runTest(t, paymentchannel.UpdateChannelState, tests) } -func runTest(t *testing.T, fn testFn, tests []test) { +func runTest(t *testing.T, fn testFn, tests []tools.TestCase[map[string]any]) { for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.height, tt.version) + t.Run(tt.Name, func(t *testing.T) { + computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.Height, tt.Version) require.NoError(t, err) for _, trace := range computeState.Trace { @@ -38,9 +53,9 @@ func runTest(t *testing.T, fn testFn, tests []test) { continue } - result, err := fn(tt.height, trace.Msg.Params) + result, err := fn(tt.Height, trace.Msg.Params) require.NoError(t, err) - require.True(t, tools.CompareResult(result, tt.expected)) + require.True(t, tools.CompareResult(result, tt.Expected)) } }) diff --git a/actors/power/power_test.go b/actors/power/power_test.go index e75026b9..95fdcf6e 100644 --- a/actors/power/power_test.go +++ b/actors/power/power_test.go @@ -1,6 +1,8 @@ package power_test import ( + _ "embed" + "encoding/json" "testing" "github.com/stretchr/testify/require" @@ -10,70 +12,86 @@ import ( "github.com/zondax/fil-parser/tools" ) -type testFn func(msg *parser.LotusMessage, height int64, raw, rawReturn []byte) (map[string]interface{}, error) +//go:embed expected.json +var expectedData []byte +var expected map[string]any -type test struct { - name string - height int64 - version string - expected map[string]interface{} +func TestMain(m *testing.M) { + if err := json.Unmarshal(expectedData, &expected); err != nil { + panic(err) + } + m.Run() } +type testFn func(msg *parser.LotusMessage, height int64, raw, rawReturn []byte) (map[string]interface{}, error) + func TestCurrentTotalPower(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("CurrentTotalPower", expected) + require.NoError(t, err) runTest(t, power.CurrentTotalPower, tests) } func TestSubmitPoRepForBulkVerify(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("SubmitPoRepForBulkVerify", expected) + require.NoError(t, err) runTest(t, power.SubmitPoRepForBulkVerify, tests) } func TestCreateMiner(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("CreateMiner", expected) + require.NoError(t, err) runTest(t, power.CreateMiner, tests) } func TestEnrollCronEvent(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("EnrollCronEvent", expected) + require.NoError(t, err) runTest(t, power.EnrollCronEvent, tests) } func TestUpdateClaimedPower(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("UpdateClaimedPower", expected) + require.NoError(t, err) runTest(t, power.UpdateClaimedPower, tests) } func TestUpdatePledgeTotal(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("UpdatePledgeTotal", expected) + require.NoError(t, err) runTest(t, power.UpdatePledgeTotal, tests) } func TestNetworkRawPower(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("NetworkRawPower", expected) + require.NoError(t, err) runTest(t, power.NetworkRawPower, tests) } func TestMinerRawPower(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("MinerRawPower", expected) + require.NoError(t, err) runTest(t, power.MinerRawPower, tests) } func TestMinerCount(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("MinerCount", expected) + require.NoError(t, err) runTest(t, power.MinerCount, tests) } func TestMinerConsensusCount(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("MinerConsensusCount", expected) + require.NoError(t, err) runTest(t, power.MinerConsensusCount, tests) } func TestPowerConstructor(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("PowerConstructor", expected) + require.NoError(t, err) + for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.height, tt.version) + t.Run(tt.Name, func(t *testing.T) { + computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.Height, tt.Version) require.NoError(t, err) for _, trace := range computeState.Trace { @@ -85,18 +103,18 @@ func TestPowerConstructor(t *testing.T) { From: trace.Msg.From, Method: trace.Msg.Method, } - result, err := power.PowerConstructor(tt.height, lotusMsg, trace.Msg.Params) + result, err := power.PowerConstructor(tt.Height, lotusMsg, trace.Msg.Params) require.NoError(t, err) - require.True(t, tools.CompareResult(result, tt.expected)) + require.True(t, tools.CompareResult(result, tt.Expected)) } }) } } -func runTest(t *testing.T, fn testFn, tests []test) { +func runTest(t *testing.T, fn testFn, tests []tools.TestCase[map[string]any]) { for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.height, tt.version) + t.Run(tt.Name, func(t *testing.T) { + computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.Height, tt.Version) require.NoError(t, err) for _, trace := range computeState.Trace { @@ -108,9 +126,9 @@ func runTest(t *testing.T, fn testFn, tests []test) { From: trace.Msg.From, Method: trace.Msg.Method, } - result, err := fn(lotusMsg, tt.height, trace.Msg.Params, trace.MsgRct.Return) + result, err := fn(lotusMsg, tt.Height, trace.Msg.Params, trace.MsgRct.Return) require.NoError(t, err) - require.True(t, tools.CompareResult(result, tt.expected)) + require.True(t, tools.CompareResult(result, tt.Expected)) } }) } diff --git a/actors/reward/reward_test.go b/actors/reward/reward_test.go index 0cd6110a..8c277768 100644 --- a/actors/reward/reward_test.go +++ b/actors/reward/reward_test.go @@ -1,6 +1,8 @@ package reward_test import ( + _ "embed" + "encoding/json" "testing" "github.com/stretchr/testify/require" @@ -9,39 +11,47 @@ import ( "github.com/zondax/fil-parser/tools" ) -type testFn func(height int64, raw []byte) (map[string]interface{}, error) +//go:embed expected.json +var expectedData []byte +var expected map[string]any -type test struct { - name string - height int64 - version string - expected map[string]interface{} +func TestMain(m *testing.M) { + if err := json.Unmarshal(expectedData, &expected); err != nil { + panic(err) + } + m.Run() } +type testFn func(height int64, raw []byte) (map[string]interface{}, error) + func TestRewardConstructor(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("RewardConstructor", expected) + require.NoError(t, err) runTest(t, reward.RewardConstructor, tests) } func TestAwardBlockReward(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("AwardBlockReward", expected) + require.NoError(t, err) runTest(t, reward.AwardBlockReward, tests) } func TestUpdateNetworkKPI(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("UpdateNetworkKPI", expected) + require.NoError(t, err) runTest(t, reward.UpdateNetworkKPI, tests) } func TestThisEpochReward(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("ThisEpochReward", expected) + require.NoError(t, err) runTest(t, reward.ThisEpochReward, tests) } -func runTest(t *testing.T, fn testFn, tests []test) { +func runTest(t *testing.T, fn testFn, tests []tools.TestCase[map[string]any]) { for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.height, tt.version) + t.Run(tt.Name, func(t *testing.T) { + computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.Height, tt.Version) require.NoError(t, err) for _, trace := range computeState.Trace { @@ -49,9 +59,9 @@ func runTest(t *testing.T, fn testFn, tests []test) { continue } - result, err := fn(tt.height, trace.Msg.Params) + result, err := fn(tt.Height, trace.Msg.Params) require.NoError(t, err) - require.True(t, tools.CompareResult(result, tt.expected)) + require.True(t, tools.CompareResult(result, tt.Expected)) } }) } diff --git a/actors/verifiedRegistry/verifiedRegistry_test.go b/actors/verifiedRegistry/verifiedRegistry_test.go index c8a2da96..4a4726c9 100644 --- a/actors/verifiedRegistry/verifiedRegistry_test.go +++ b/actors/verifiedRegistry/verifiedRegistry_test.go @@ -1,6 +1,8 @@ package verifiedregistry_test import ( + _ "embed" + "encoding/json" "testing" "github.com/stretchr/testify/require" @@ -9,88 +11,107 @@ import ( "github.com/zondax/fil-parser/tools" ) +//go:embed expected.json +var expectedData []byte +var expected map[string]any + +func TestMain(m *testing.M) { + if err := json.Unmarshal(expectedData, &expected); err != nil { + panic(err) + } + m.Run() +} + type testFn func(height int64, raw []byte) (map[string]interface{}, error) type testFn2 func(height int64, raw, rawReturn []byte) (map[string]interface{}, error) -type test struct { - name string - height int64 - version string - expected map[string]interface{} -} func TestAddVerifier(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("AddVerifier", expected) + require.NoError(t, err) runTest(t, verifiedregistry.AddVerifier, tests) } func TestRemoveVerifier(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("RemoveVerifier", expected) + require.NoError(t, err) runTest(t, verifiedregistry.RemoveVerifier, tests) } func TestAddVerifiedClient(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("AddVerifiedClient", expected) + require.NoError(t, err) runTest(t, verifiedregistry.AddVerifiedClient, tests) } func TestUseBytes(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("UseBytes", expected) + require.NoError(t, err) runTest(t, verifiedregistry.UseBytes, tests) } func TestRestoreBytes(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("RestoreBytes", expected) + require.NoError(t, err) runTest(t, verifiedregistry.RestoreBytes, tests) } func TestRemoveVerifiedClientDataCap(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("RemoveVerifiedClientDataCap", expected) + require.NoError(t, err) runTest(t, verifiedregistry.RemoveVerifiedClientDataCap, tests) } func TestDeprecated1(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("Deprecated1", expected) + require.NoError(t, err) runTest(t, verifiedregistry.Deprecated1, tests) } func TestDeprecated2(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("Deprecated2", expected) + require.NoError(t, err) runTest(t, verifiedregistry.Deprecated2, tests) } func TestClaimAllocations(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("ClaimAllocations", expected) + require.NoError(t, err) runTest2(t, verifiedregistry.ClaimAllocations, tests) } func TestGetClaims(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("GetClaims", expected) + require.NoError(t, err) runTest2(t, verifiedregistry.GetClaims, tests) } func TestExtendClaimTerms(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("ExtendClaimTerms", expected) + require.NoError(t, err) runTest2(t, verifiedregistry.ExtendClaimTerms, tests) } func TestRemoveExpiredClaims(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("RemoveExpiredClaims", expected) + require.NoError(t, err) runTest2(t, verifiedregistry.RemoveExpiredClaims, tests) } func TestVerifregUniversalReceiverHook(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("VerifregUniversalReceiverHook", expected) + require.NoError(t, err) runTest2(t, verifiedregistry.VerifregUniversalReceiverHook, tests) } func TestRemoveExpiredAllocations(t *testing.T) { - tests := []test{} + tests, err := tools.LoadTestData[map[string]any]("RemoveExpiredAllocations", expected) + require.NoError(t, err) runTest2(t, verifiedregistry.RemoveExpiredAllocations, tests) } -func runTest(t *testing.T, fn testFn, tests []test) { +func runTest(t *testing.T, fn testFn, tests []tools.TestCase[map[string]any]) { for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.height, tt.version) + t.Run(tt.Name, func(t *testing.T) { + computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.Height, tt.Version) require.NoError(t, err) for _, trace := range computeState.Trace { @@ -98,18 +119,18 @@ func runTest(t *testing.T, fn testFn, tests []test) { continue } - result, err := fn(tt.height, trace.Msg.Params) + result, err := fn(tt.Height, trace.Msg.Params) require.NoError(t, err) - require.True(t, tools.CompareResult(result, tt.expected)) + require.True(t, tools.CompareResult(result, tt.Expected)) } }) } } -func runTest2(t *testing.T, fn testFn2, tests []test) { +func runTest2(t *testing.T, fn testFn2, tests []tools.TestCase[map[string]any]) { for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.height, tt.version) + t.Run(tt.Name, func(t *testing.T) { + computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.Height, tt.Version) require.NoError(t, err) for _, trace := range computeState.Trace { @@ -117,9 +138,9 @@ func runTest2(t *testing.T, fn testFn2, tests []test) { continue } - result, err := fn(tt.height, trace.Msg.Params, trace.MsgRct.Return) + result, err := fn(tt.Height, trace.Msg.Params, trace.MsgRct.Return) require.NoError(t, err) - require.True(t, tools.CompareResult(result, tt.expected)) + require.True(t, tools.CompareResult(result, tt.Expected)) } }) } diff --git a/tools/testutil.go b/tools/testutil.go index f6070bd6..44a49e3f 100644 --- a/tools/testutil.go +++ b/tools/testutil.go @@ -156,3 +156,42 @@ func ComputeState[T any](height int64, version string) (*T, error) { func CompareResult(result1, result2 map[string]any) bool { return reflect.DeepEqual(result1, result2) } + +type TestCase[T any] struct { + Name string + Version string + Url string + Height int64 + TipsetKey filTypes.TipSetKey + Expected T + Address *types.AddressInfo +} + +func LoadTestData[T any](fnName string, expected map[string]any) ([]TestCase[T], error) { + var tests []TestCase[T] + for _, version := range GetSupportedVersions() { + + versionData := expected[version.String()] + if versionData == nil { + return nil, fmt.Errorf("version %s not found in expected data", version.String()) + } + tmp, ok := versionData.(map[string]any) + if !ok { + return nil, fmt.Errorf("version %s not found in expected data", version.String()) + } + fnData := tmp[fnName] + + if fnData == nil { + return nil, fmt.Errorf("function %s not found in version %s", fnName, version.String()) + } + + tests = append(tests, TestCase[T]{ + Name: fnName, + Version: version.String(), + Url: NodeUrl, + Height: int64(version), + Expected: fnData.(T), + }) + } + return tests, nil +} diff --git a/tools/version_mapping.go b/tools/version_mapping.go index e236605b..c0a61660 100644 --- a/tools/version_mapping.go +++ b/tools/version_mapping.go @@ -1,5 +1,7 @@ package tools +import "fmt" + type version int64 var supportedVersions = []version{V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22} @@ -20,6 +22,16 @@ func (v version) next() version { return v } +func (v version) String() string { + return fmt.Sprintf("V%d", v) +} +func GetSupportedVersions() []version { + // Create a new slice with same length and copy all elements + result := make([]version, len(supportedVersions)) + copy(result, supportedVersions) + return result +} + const ( LatestVersion version = V22 V1 version = 0 From 43af4b10db1fc4b20bf70427fc927fed978ef510 Mon Sep 17 00:00:00 2001 From: Eric Mokaya Date: Wed, 22 Jan 2025 17:33:26 +0300 Subject: [PATCH 11/16] feat: allow seperate version height ranges per network --- actors/account/account.go | 14 +- actors/account/account_test.go | 4 +- actors/cron/cron.go | 16 +- actors/cron/cron_test.go | 4 +- actors/datacap/allowance.go | 56 +-- actors/datacap/allowance_test.go | 4 +- actors/datacap/burn.go | 54 +-- actors/datacap/granularity.go | 14 +- actors/datacap/granularity_test.go | 2 +- actors/datacap/mint.go | 18 +- actors/datacap/transfer.go | 18 +- actors/eam/create.go | 48 +-- actors/eam/create_test.go | 4 +- actors/evm/evm.go | 84 ++--- actors/evm/evm_test.go | 10 +- actors/init/init.go | 54 +-- actors/init/int_test.go | 6 +- actors/market/market.go | 321 ++++++++---------- actors/market/market_test.go | 10 +- actors/miner/address.go | 144 ++++---- actors/miner/address_test.go | 6 +- actors/miner/balance.go | 54 +-- actors/miner/miner.go | 234 ++++++------- actors/miner/miner_test.go | 4 +- actors/miner/sector.go | 219 ++++++------ actors/miner/sector_test.go | 2 +- actors/multisig/multisig.go | 144 ++++---- actors/multisig/multisig_test.go | 8 +- actors/multisig/utils.go | 38 +-- actors/multisig/values.go | 250 +++++++------- actors/multisig/values_test.go | 4 +- actors/multisig/verifier.go | 18 +- actors/paymentChannel/paymentChannel.go | 36 +- actors/paymentChannel/paymentChannel_test.go | 4 +- actors/power/power.go | 182 +++++----- actors/power/power_test.go | 6 +- actors/reward/reward.go | 40 +-- actors/reward/reward_test.go | 4 +- actors/verifiedRegistry/verifiedRegistry.go | 236 ++++++------- .../verifiedRegistry/verifiedRegistry_test.go | 8 +- tools/testutil.go | 1 + tools/version_mapping.go | 66 ++-- 42 files changed, 1193 insertions(+), 1256 deletions(-) diff --git a/actors/account/account.go b/actors/account/account.go index 8da8dfa7..a769996e 100644 --- a/actors/account/account.go +++ b/actors/account/account.go @@ -15,7 +15,7 @@ import ( "github.com/zondax/fil-parser/tools" ) -func PubkeyAddress(raw, rawReturn []byte) (map[string]interface{}, error) { +func PubkeyAddress(network string, raw, rawReturn []byte) (map[string]interface{}, error) { metadata := make(map[string]interface{}) metadata[parser.ParamsKey] = base64.StdEncoding.EncodeToString(raw) reader := bytes.NewReader(rawReturn) @@ -28,17 +28,17 @@ func PubkeyAddress(raw, rawReturn []byte) (map[string]interface{}, error) { return metadata, nil } -func AuthenticateMessage(height int64, raw, rawReturn []byte) (map[string]interface{}, error) { +func AuthenticateMessage(network string, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return nil, fmt.Errorf("not supported") - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return authenticateMessageGeneric[*accountv9.AuthenticateMessageParams, *accountv9.AuthenticateMessageParams](raw, rawReturn, &accountv9.AuthenticateMessageParams{}) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return authenticateMessageGeneric[*accountv10.AuthenticateMessageParams, *accountv10.AuthenticateMessageParams](raw, rawReturn, &accountv10.AuthenticateMessageParams{}) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return authenticateMessageGeneric[*accountv11.AuthenticateMessageParams, *accountv11.AuthenticateMessageParams](raw, rawReturn, &accountv11.AuthenticateMessageParams{}) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return authenticateMessageGeneric[*accountv14.AuthenticateMessageParams, *accountv14.AuthenticateMessageParams](raw, rawReturn, &accountv14.AuthenticateMessageParams{}) default: return authenticateMessageGeneric[*accountv15.AuthenticateMessageParams, *accountv15.AuthenticateMessageParams](raw, rawReturn, &accountv15.AuthenticateMessageParams{}) diff --git a/actors/account/account_test.go b/actors/account/account_test.go index 23d7f9aa..ff9925ac 100644 --- a/actors/account/account_test.go +++ b/actors/account/account_test.go @@ -46,7 +46,7 @@ func TestAuthenticateMessage(t *testing.T) { if trace.Msg == nil { continue } - result, err := account.AuthenticateMessage(tt.Height, trace.Msg.Params, trace.MsgRct.Return) + result, err := account.AuthenticateMessage(tt.Network, tt.Height, trace.Msg.Params, trace.MsgRct.Return) require.NoError(t, err) require.True(t, tools.CompareResult(result, tt.Expected)) } @@ -67,7 +67,7 @@ func TestPubkeyAddress(t *testing.T) { if trace.Msg == nil { continue } - result, err := account.PubkeyAddress(trace.Msg.Params, trace.MsgRct.Return) + result, err := account.PubkeyAddress(tt.Network, trace.Msg.Params, trace.MsgRct.Return) require.NoError(t, err) require.True(t, tools.CompareResult(result, tt.Expected)) } diff --git a/actors/cron/cron.go b/actors/cron/cron.go index 8e439d6b..c21374a3 100644 --- a/actors/cron/cron.go +++ b/actors/cron/cron.go @@ -12,21 +12,21 @@ import ( ) // TODO: update to correct height ranges -func CronConstructor(height int64, raw []byte) (map[string]interface{}, error) { +func CronConstructor(network string, height int64, raw []byte) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return cronConstructorGeneric[*cronv8.ConstructorParams](raw, &cronv8.ConstructorParams{}) - case tools.V7.IsSupported(height): + case tools.V7.IsSupported(network, height): return cronConstructorGeneric[*cronv7.ConstructorParams](raw, &cronv7.ConstructorParams{}) - case tools.V6.IsSupported(height): + case tools.V6.IsSupported(network, height): return cronConstructorGeneric[*cronv6.ConstructorParams](raw, &cronv6.ConstructorParams{}) - case tools.V5.IsSupported(height): + case tools.V5.IsSupported(network, height): return cronConstructorGeneric[*cronv5.ConstructorParams](raw, &cronv5.ConstructorParams{}) - case tools.V4.IsSupported(height): + case tools.V4.IsSupported(network, height): return cronConstructorGeneric[*cronv4.ConstructorParams](raw, &cronv4.ConstructorParams{}) - case tools.V3.IsSupported(height): + case tools.V3.IsSupported(network, height): return cronConstructorGeneric[*cronv3.ConstructorParams](raw, &cronv3.ConstructorParams{}) - case tools.V2.IsSupported(height): + case tools.V2.IsSupported(network, height): return cronConstructorGeneric[*cronv2.ConstructorParams](raw, &cronv2.ConstructorParams{}) } return nil, nil diff --git a/actors/cron/cron_test.go b/actors/cron/cron_test.go index 240aa9f9..17877da4 100644 --- a/actors/cron/cron_test.go +++ b/actors/cron/cron_test.go @@ -22,7 +22,7 @@ func TestMain(m *testing.M) { m.Run() } -type testFn func(height int64, raw []byte) (map[string]interface{}, error) +type testFn func(network string, height int64, raw []byte) (map[string]interface{}, error) func TestCronConstructor(t *testing.T) { tests, err := tools.LoadTestData[map[string]any]("CronConstructor", expected) @@ -41,7 +41,7 @@ func runTest(t *testing.T, fn testFn, tests []tools.TestCase[map[string]any]) { continue } - result, err := fn(tt.Height, trace.Msg.Params) + result, err := fn(tt.Network, tt.Height, trace.Msg.Params) require.NoError(t, err) require.True(t, tools.CompareResult(result, tt.Expected)) } diff --git a/actors/datacap/allowance.go b/actors/datacap/allowance.go index 0046ca63..20cb97a3 100644 --- a/actors/datacap/allowance.go +++ b/actors/datacap/allowance.go @@ -12,73 +12,73 @@ import ( "github.com/zondax/fil-parser/tools" ) -func IncreaseAllowance(height int64, raw, rawReturn []byte) (map[string]interface{}, error) { +func IncreaseAllowance(network string, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return nil, fmt.Errorf("not supported") - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return parse[*datacapv9.IncreaseAllowanceParams, *abi.TokenAmount](raw, rawReturn, true) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parse[*datacapv10.IncreaseAllowanceParams, *abi.TokenAmount](raw, rawReturn, true) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parse[*datacapv11.IncreaseAllowanceParams, *abi.TokenAmount](raw, rawReturn, true) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parse[*datacapv14.IncreaseAllowanceParams, *abi.TokenAmount](raw, rawReturn, true) - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parse[*datacapv15.IncreaseAllowanceParams, *abi.TokenAmount](raw, rawReturn, true) } return nil, fmt.Errorf("not supported") } -func DecreaseAllowance(height int64, raw, rawReturn []byte) (map[string]interface{}, error) { +func DecreaseAllowance(network string, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return nil, fmt.Errorf("not supported") - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return parse[*datacapv9.DecreaseAllowanceParams, *abi.TokenAmount](raw, rawReturn, true) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parse[*datacapv10.DecreaseAllowanceParams, *abi.TokenAmount](raw, rawReturn, true) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parse[*datacapv11.DecreaseAllowanceParams, *abi.TokenAmount](raw, rawReturn, true) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parse[*datacapv14.DecreaseAllowanceParams, *abi.TokenAmount](raw, rawReturn, true) - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parse[*datacapv15.DecreaseAllowanceParams, *abi.TokenAmount](raw, rawReturn, true) } return nil, fmt.Errorf("not supported") } -func RevokeAllowance(height int64, raw, rawReturn []byte) (map[string]interface{}, error) { +func RevokeAllowance(network string, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return nil, fmt.Errorf("not supported") - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return parse[*datacapv9.RevokeAllowanceParams, *abi.TokenAmount](raw, rawReturn, true) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parse[*datacapv10.RevokeAllowanceParams, *abi.TokenAmount](raw, rawReturn, true) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parse[*datacapv11.RevokeAllowanceParams, *abi.TokenAmount](raw, rawReturn, true) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parse[*datacapv14.RevokeAllowanceParams, *abi.TokenAmount](raw, rawReturn, true) - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parse[*datacapv15.RevokeAllowanceParams, *abi.TokenAmount](raw, rawReturn, true) } return nil, fmt.Errorf("not supported") } -func GetAllowance(height int64, raw, rawReturn []byte) (map[string]interface{}, error) { +func GetAllowance(network string, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return nil, fmt.Errorf("not supported") - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return parse[*datacapv9.GetAllowanceParams, *abi.TokenAmount](raw, rawReturn, true) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parse[*datacapv10.GetAllowanceParams, *abi.TokenAmount](raw, rawReturn, true) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parse[*datacapv11.GetAllowanceParams, *abi.TokenAmount](raw, rawReturn, true) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parse[*datacapv14.GetAllowanceParams, *abi.TokenAmount](raw, rawReturn, true) - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parse[*datacapv15.GetAllowanceParams, *abi.TokenAmount](raw, rawReturn, true) } return nil, fmt.Errorf("not supported") diff --git a/actors/datacap/allowance_test.go b/actors/datacap/allowance_test.go index 7d209b2c..5debae13 100644 --- a/actors/datacap/allowance_test.go +++ b/actors/datacap/allowance_test.go @@ -10,7 +10,7 @@ import ( typesV2 "github.com/zondax/fil-parser/parser/v2/types" ) -type testFn func(height int64, raw, rawReturn []byte) (map[string]interface{}, error) +type testFn func(network string, height int64, raw, rawReturn []byte) (map[string]interface{}, error) func TestIncreaseAllowance(t *testing.T) { tests, err := tools.LoadTestData[map[string]any]("IncreaseAllowance", expected) @@ -50,7 +50,7 @@ func runTest(t *testing.T, fn testFn, tests []tools.TestCase[map[string]any]) { if trace.Msg == nil { continue } - result, err := fn(tt.Height, trace.Msg.Params, trace.MsgRct.Return) + result, err := fn(tt.Network, tt.Height, trace.Msg.Params, trace.MsgRct.Return) require.NoError(t, err) require.True(t, tools.CompareResult(result, tt.Expected)) } diff --git a/actors/datacap/burn.go b/actors/datacap/burn.go index ad452169..f39708fa 100644 --- a/actors/datacap/burn.go +++ b/actors/datacap/burn.go @@ -13,67 +13,67 @@ import ( "github.com/zondax/fil-parser/tools" ) -func BurnExported(height int64, raw, rawReturn []byte) (map[string]interface{}, error) { +func BurnExported(network string, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return nil, fmt.Errorf("not supported") - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return parse[*datacapv9.BurnParams, *datacapv9.BurnReturn](raw, rawReturn, true) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parse[*datacapv10.BurnParams, *datacapv10.BurnReturn](raw, rawReturn, true) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parse[*datacapv11.BurnParams, *datacapv11.BurnReturn](raw, rawReturn, true) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parse[*datacapv12.BurnParams, *datacapv12.BurnReturn](raw, rawReturn, true) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parse[*datacapv13.BurnParams, *datacapv13.BurnReturn](raw, rawReturn, true) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parse[*datacapv14.BurnParams, *datacapv14.BurnReturn](raw, rawReturn, true) - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parse[*datacapv15.BurnParams, *datacapv15.BurnReturn](raw, rawReturn, true) } return nil, fmt.Errorf("not supported") } -func BurnFromExported(height int64, raw, rawReturn []byte) (map[string]interface{}, error) { +func BurnFromExported(network string, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return nil, fmt.Errorf("not supported") - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return parse[*datacapv9.BurnFromParams, *datacapv9.BurnFromReturn](raw, rawReturn, true) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parse[*datacapv10.BurnFromParams, *datacapv10.BurnFromReturn](raw, rawReturn, true) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parse[*datacapv11.BurnFromParams, *datacapv11.BurnFromReturn](raw, rawReturn, true) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parse[*datacapv12.BurnFromParams, *datacapv12.BurnFromReturn](raw, rawReturn, true) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parse[*datacapv13.BurnFromParams, *datacapv13.BurnFromReturn](raw, rawReturn, true) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parse[*datacapv14.BurnFromParams, *datacapv14.BurnFromReturn](raw, rawReturn, true) - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parse[*datacapv15.BurnFromParams, *datacapv15.BurnFromReturn](raw, rawReturn, true) } return nil, fmt.Errorf("not supported") } -func DestroyExported(height int64, raw, rawReturn []byte) (map[string]interface{}, error) { +func DestroyExported(network string, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return nil, fmt.Errorf("not supported") - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return parse[*datacapv9.DestroyParams, *datacapv9.BurnReturn](raw, rawReturn, true) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parse[*datacapv10.DestroyParams, *datacapv10.BurnReturn](raw, rawReturn, true) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parse[*datacapv11.DestroyParams, *datacapv11.BurnReturn](raw, rawReturn, true) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parse[*datacapv12.DestroyParams, *datacapv12.BurnReturn](raw, rawReturn, true) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parse[*datacapv13.DestroyParams, *datacapv13.BurnReturn](raw, rawReturn, true) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parse[*datacapv14.DestroyParams, *datacapv14.BurnReturn](raw, rawReturn, true) - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parse[*datacapv15.DestroyParams, *datacapv15.BurnReturn](raw, rawReturn, true) } return nil, fmt.Errorf("not supported") diff --git a/actors/datacap/granularity.go b/actors/datacap/granularity.go index 5a402b1f..9d17b754 100644 --- a/actors/datacap/granularity.go +++ b/actors/datacap/granularity.go @@ -12,39 +12,39 @@ import ( "github.com/zondax/fil-parser/tools" ) -func GranularityExported(height int64, rawReturn []byte) (map[string]interface{}, error) { +func GranularityExported(network string, height int64, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return nil, fmt.Errorf("not supported") - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): data, err := parse[*datacapv10.GranularityReturn, *datacapv10.GranularityReturn](rawReturn, nil, false) if err != nil { return nil, err } data[parser.ReturnKey] = data[parser.ParamsKey] return data, nil - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): data, err := parse[*datacapv11.GranularityReturn, *datacapv11.GranularityReturn](rawReturn, nil, false) if err != nil { return nil, err } data[parser.ReturnKey] = data[parser.ParamsKey] return data, nil - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): data, err := parse[*datacapv12.GranularityReturn, *datacapv12.GranularityReturn](rawReturn, nil, false) if err != nil { return nil, err } data[parser.ReturnKey] = data[parser.ParamsKey] return data, nil - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): data, err := parse[*datacapv14.GranularityReturn, *datacapv14.GranularityReturn](rawReturn, nil, false) if err != nil { return nil, err } data[parser.ReturnKey] = data[parser.ParamsKey] return data, nil - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): data, err := parse[*datacapv15.GranularityReturn, *datacapv15.GranularityReturn](rawReturn, nil, false) if err != nil { return nil, err diff --git a/actors/datacap/granularity_test.go b/actors/datacap/granularity_test.go index b55c2e07..ce65a1cb 100644 --- a/actors/datacap/granularity_test.go +++ b/actors/datacap/granularity_test.go @@ -22,7 +22,7 @@ func TestGranularityExported(t *testing.T) { if trace.Msg == nil { continue } - result, err := datacap.GranularityExported(tt.Height, trace.MsgRct.Return) + result, err := datacap.GranularityExported(tt.Network, tt.Height, trace.MsgRct.Return) require.NoError(t, err) require.True(t, tools.CompareResult(result, tt.Expected)) } diff --git a/actors/datacap/mint.go b/actors/datacap/mint.go index 23802b66..60b2c658 100644 --- a/actors/datacap/mint.go +++ b/actors/datacap/mint.go @@ -18,23 +18,23 @@ type ( mintReturn = unmarshalCBOR ) -func MintExported(height int64, raw, rawReturn []byte) (map[string]interface{}, error) { +func MintExported(network string, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return nil, fmt.Errorf("not supported") - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return parse[*datacapv9.MintParams, *datacapv9.MintReturn](raw, rawReturn, true) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parse[*datacapv10.MintParams, *datacapv10.MintReturn](raw, rawReturn, true) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parse[*datacapv11.MintParams, *datacapv11.MintReturn](raw, rawReturn, true) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parse[*datacapv12.MintParams, *datacapv12.MintReturn](raw, rawReturn, true) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parse[*datacapv13.MintParams, *datacapv13.MintReturn](raw, rawReturn, true) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parse[*datacapv14.MintParams, *datacapv14.MintReturn](raw, rawReturn, true) - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parse[*datacapv15.MintParams, *datacapv15.MintReturn](raw, rawReturn, true) } return nil, fmt.Errorf("not supported") diff --git a/actors/datacap/transfer.go b/actors/datacap/transfer.go index 1536258b..7a808bc3 100644 --- a/actors/datacap/transfer.go +++ b/actors/datacap/transfer.go @@ -13,23 +13,23 @@ import ( "github.com/zondax/fil-parser/tools" ) -func TransferExported(height int64, raw, rawReturn []byte) (map[string]interface{}, error) { +func TransferExported(network string, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return nil, fmt.Errorf("not supported") - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return parse[*datacapv9.TransferParams, *datacapv9.TransferReturn](raw, rawReturn, true) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parse[*datacapv10.TransferParams, *datacapv10.TransferReturn](raw, rawReturn, true) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parse[*datacapv11.TransferParams, *datacapv11.TransferReturn](raw, rawReturn, true) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parse[*datacapv12.TransferParams, *datacapv12.TransferReturn](raw, rawReturn, true) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parse[*datacapv13.TransferParams, *datacapv13.TransferReturn](raw, rawReturn, true) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parse[*datacapv14.TransferParams, *datacapv14.TransferReturn](raw, rawReturn, true) - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parse[*datacapv15.TransferParams, *datacapv15.TransferReturn](raw, rawReturn, true) } return nil, fmt.Errorf("not supported") diff --git a/actors/eam/create.go b/actors/eam/create.go index 05834656..d8cd63f2 100644 --- a/actors/eam/create.go +++ b/actors/eam/create.go @@ -15,64 +15,64 @@ import ( "github.com/zondax/fil-parser/types" ) -func ParseCreateExternal(height int64, rawParams, rawReturn []byte, msgCid cid.Cid) (map[string]interface{}, *types.AddressInfo, error) { +func ParseCreateExternal(network string, height int64, rawParams, rawReturn []byte, msgCid cid.Cid) (map[string]interface{}, *types.AddressInfo, error) { external := true switch { - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parseCreate[*eamv15.CreateExternalReturn](rawParams, rawReturn, msgCid, external) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parseCreate[*eamv14.CreateExternalReturn](rawParams, rawReturn, msgCid, external) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parseCreate[*eamv13.CreateExternalReturn](rawParams, rawReturn, msgCid, external) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parseCreate[*eamv12.CreateExternalReturn](rawParams, rawReturn, msgCid, external) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parseCreate[*eamv11.CreateExternalReturn](rawParams, rawReturn, msgCid, external) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parseCreate[*eamv10.CreateExternalReturn](rawParams, rawReturn, msgCid, external) - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return nil, nil, fmt.Errorf("unsupported height: %d", height) } return nil, nil, fmt.Errorf("unsupported height: %d", height) } -func ParseCreate(height int64, rawParams, rawReturn []byte, msgCid cid.Cid) (map[string]interface{}, *types.AddressInfo, error) { +func ParseCreate(network string, height int64, rawParams, rawReturn []byte, msgCid cid.Cid) (map[string]interface{}, *types.AddressInfo, error) { external := false switch { - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parseCreate[*eamv15.CreateReturn](rawParams, rawReturn, msgCid, external) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parseCreate[*eamv14.CreateReturn](rawParams, rawReturn, msgCid, external) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parseCreate[*eamv13.CreateReturn](rawParams, rawReturn, msgCid, external) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parseCreate[*eamv12.CreateReturn](rawParams, rawReturn, msgCid, external) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parseCreate[*eamv11.CreateReturn](rawParams, rawReturn, msgCid, external) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parseCreate[*eamv10.CreateReturn](rawParams, rawReturn, msgCid, external) - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return nil, nil, fmt.Errorf("unsupported height: %d", height) } return nil, nil, fmt.Errorf("unsupported height: %d", height) } -func ParseCreate2(height int64, rawParams, rawReturn []byte, msgCid cid.Cid) (map[string]interface{}, *types.AddressInfo, error) { +func ParseCreate2(network string, height int64, rawParams, rawReturn []byte, msgCid cid.Cid) (map[string]interface{}, *types.AddressInfo, error) { external := false switch { - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parseCreate[*eamv15.Create2Return](rawParams, rawReturn, msgCid, external) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parseCreate[*eamv14.Create2Return](rawParams, rawReturn, msgCid, external) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parseCreate[*eamv13.Create2Return](rawParams, rawReturn, msgCid, external) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parseCreate[*eamv12.Create2Return](rawParams, rawReturn, msgCid, external) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parseCreate[*eamv11.Create2Return](rawParams, rawReturn, msgCid, external) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parseCreate[*eamv10.Create2Return](rawParams, rawReturn, msgCid, external) - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return nil, nil, fmt.Errorf("unsupported height: %d", height) } return nil, nil, fmt.Errorf("unsupported height: %d", height) diff --git a/actors/eam/create_test.go b/actors/eam/create_test.go index f7915c1a..edc2bde5 100644 --- a/actors/eam/create_test.go +++ b/actors/eam/create_test.go @@ -25,7 +25,7 @@ func TestMain(m *testing.M) { os.Exit(m.Run()) } -type testFn func(height int64, raw, rawReturn []byte, msgCid cid.Cid) (map[string]interface{}, *types.AddressInfo, error) +type testFn func(network string, height int64, raw, rawReturn []byte, msgCid cid.Cid) (map[string]interface{}, *types.AddressInfo, error) func TestParseCreateExternal(t *testing.T) { tests, err := tools.LoadTestData[map[string]any]("CreateExternalExported", expected) @@ -58,7 +58,7 @@ func runTest(t *testing.T, fn testFn, tests []tools.TestCase[map[string]any]) { if trace.Msg == nil { continue } - result, addrInfo, err := fn(tt.Height, trace.Msg.Params, trace.MsgRct.Return, trace.Msg.Cid()) + result, addrInfo, err := fn(tt.Network, tt.Height, trace.Msg.Params, trace.MsgRct.Return, trace.Msg.Cid()) require.NoError(t, err) require.True(t, tools.CompareResult(result, tt.Expected)) require.Equal(t, addrInfo, tt.Address) diff --git a/actors/evm/evm.go b/actors/evm/evm.go index a150434d..2c5e6e8b 100644 --- a/actors/evm/evm.go +++ b/actors/evm/evm.go @@ -16,7 +16,7 @@ import ( "github.com/zondax/fil-parser/tools" ) -func InvokeContract(rawParams, rawReturn []byte) (map[string]interface{}, error) { +func InvokeContract(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { metadata := make(map[string]interface{}) reader := bytes.NewReader(rawParams) metadata[parser.ParamsKey] = parser.EthPrefix + hex.EncodeToString(rawParams) @@ -44,45 +44,45 @@ func InvokeContract(rawParams, rawReturn []byte) (map[string]interface{}, error) return metadata, nil } -func Resurrect(height int64, raw []byte) (map[string]interface{}, error) { +func Resurrect(network string, height int64, raw []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parse[*evmv15.ResurrectParams, *evmv15.ResurrectParams](raw, nil, false) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parse[*evmv14.ResurrectParams, *evmv14.ResurrectParams](raw, nil, false) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parse[*evmv13.ResurrectParams, *evmv13.ResurrectParams](raw, nil, false) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parse[*evmv12.ResurrectParams, *evmv12.ResurrectParams](raw, nil, false) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parse[*evmv11.ResurrectParams, *evmv11.ResurrectParams](raw, nil, false) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parse[*evmv10.ResurrectParams, *evmv10.ResurrectParams](raw, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) } -func InvokeContractDelegate(height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { +func InvokeContractDelegate(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parse[*evmv15.DelegateCallParams, *abi.CborBytes](rawParams, rawReturn, true) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parse[*evmv14.DelegateCallParams, *abi.CborBytes](rawParams, rawReturn, true) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parse[*evmv13.DelegateCallParams, *abi.CborBytes](rawParams, rawReturn, true) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parse[*evmv12.DelegateCallParams, *abi.CborBytes](rawParams, rawReturn, true) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parse[*evmv11.DelegateCallParams, *abi.CborBytes](rawParams, rawReturn, true) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parse[*evmv10.DelegateCallParams, *abi.CborBytes](rawParams, rawReturn, true) } return nil, fmt.Errorf("unsupported height: %d", height) } -func GetByteCode(height int64, raw []byte) (map[string]interface{}, error) { +func GetByteCode(network string, height int64, raw []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): data, err := parse[*evmv15.GetBytecodeReturn, *evmv15.GetBytecodeReturn](raw, nil, false) if err != nil { return nil, err @@ -90,7 +90,7 @@ func GetByteCode(height int64, raw []byte) (map[string]interface{}, error) { // The return value is the same as the params data[parser.ReturnKey] = data[parser.ParamsKey] return data, nil - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): data, err := parse[*evmv14.GetBytecodeReturn, *evmv14.GetBytecodeReturn](raw, nil, false) if err != nil { return nil, err @@ -98,7 +98,7 @@ func GetByteCode(height int64, raw []byte) (map[string]interface{}, error) { // The return value is the same as the params data[parser.ReturnKey] = data[parser.ParamsKey] return data, nil - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): data, err := parse[*evmv13.GetBytecodeReturn, *evmv13.GetBytecodeReturn](raw, nil, false) if err != nil { return nil, err @@ -106,7 +106,7 @@ func GetByteCode(height int64, raw []byte) (map[string]interface{}, error) { // The return value is the same as the params data[parser.ReturnKey] = data[parser.ParamsKey] return data, nil - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): data, err := parse[*evmv11.GetBytecodeReturn, *evmv11.GetBytecodeReturn](raw, nil, false) if err != nil { return nil, err @@ -114,7 +114,7 @@ func GetByteCode(height int64, raw []byte) (map[string]interface{}, error) { // The return value is the same as the params data[parser.ReturnKey] = data[parser.ParamsKey] return data, nil - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): data, err := parse[*evmv10.GetBytecodeReturn, *evmv10.GetBytecodeReturn](raw, nil, false) if err != nil { return nil, err @@ -126,9 +126,9 @@ func GetByteCode(height int64, raw []byte) (map[string]interface{}, error) { return nil, fmt.Errorf("unsupported height: %d", height) } -func GetByteCodeHash(height int64, raw []byte) (map[string]interface{}, error) { +func GetByteCodeHash(network string, height int64, raw []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): data, err := parse[*abi.CborBytes, *abi.CborBytes](raw, nil, false) if err != nil { return nil, err @@ -136,7 +136,7 @@ func GetByteCodeHash(height int64, raw []byte) (map[string]interface{}, error) { // The return value is the same as the params data[parser.ReturnKey] = data[parser.ParamsKey] return data, nil - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): data, err := parse[*abi.CborBytes, *abi.CborBytes](raw, nil, false) if err != nil { return nil, err @@ -144,7 +144,7 @@ func GetByteCodeHash(height int64, raw []byte) (map[string]interface{}, error) { // The return value is the same as the params data[parser.ReturnKey] = data[parser.ParamsKey] return data, nil - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): data, err := parse[*abi.CborBytes, *abi.CborBytes](raw, nil, false) if err != nil { return nil, err @@ -152,7 +152,7 @@ func GetByteCodeHash(height int64, raw []byte) (map[string]interface{}, error) { // The return value is the same as the params data[parser.ReturnKey] = data[parser.ParamsKey] return data, nil - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): data, err := parse[*abi.CborBytes, *abi.CborBytes](raw, nil, false) if err != nil { return nil, err @@ -160,7 +160,7 @@ func GetByteCodeHash(height int64, raw []byte) (map[string]interface{}, error) { // The return value is the same as the params data[parser.ReturnKey] = data[parser.ParamsKey] return data, nil - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): data, err := parse[*abi.CborBytes, *abi.CborBytes](raw, nil, false) if err != nil { return nil, err @@ -168,7 +168,7 @@ func GetByteCodeHash(height int64, raw []byte) (map[string]interface{}, error) { // The return value is the same as the params data[parser.ReturnKey] = data[parser.ParamsKey] return data, nil - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): data, err := parse[*abi.CborBytes, *abi.CborBytes](raw, nil, false) if err != nil { return nil, err @@ -180,37 +180,37 @@ func GetByteCodeHash(height int64, raw []byte) (map[string]interface{}, error) { return nil, fmt.Errorf("unsupported height: %d", height) } -func EVMConstructor(height int64, raw []byte) (map[string]interface{}, error) { +func EVMConstructor(network string, height int64, raw []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parse[*evmv15.ConstructorParams, *evmv15.ConstructorParams](raw, nil, false) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parse[*evmv14.ConstructorParams, *evmv14.ConstructorParams](raw, nil, false) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parse[*evmv13.ConstructorParams, *evmv13.ConstructorParams](raw, nil, false) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parse[*evmv12.ConstructorParams, *evmv12.ConstructorParams](raw, nil, false) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parse[*evmv11.ConstructorParams, *evmv11.ConstructorParams](raw, nil, false) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parse[*evmv10.ConstructorParams, *evmv10.ConstructorParams](raw, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) } -func GetStorageAt(height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { +func GetStorageAt(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parse[*evmv15.GetStorageAtParams, *abi.CborBytes](rawParams, rawReturn, true) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parse[*evmv14.GetStorageAtParams, *abi.CborBytes](rawParams, rawReturn, true) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parse[*evmv13.GetStorageAtParams, *abi.CborBytes](rawParams, rawReturn, true) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parse[*evmv12.GetStorageAtParams, *abi.CborBytes](rawParams, rawReturn, true) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parse[*evmv11.GetStorageAtParams, *abi.CborBytes](rawParams, rawReturn, true) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parse[*evmv10.GetStorageAtParams, *abi.CborBytes](rawParams, rawReturn, true) } return nil, fmt.Errorf("unsupported height: %d", height) diff --git a/actors/evm/evm_test.go b/actors/evm/evm_test.go index 91ce365b..41a1bd77 100644 --- a/actors/evm/evm_test.go +++ b/actors/evm/evm_test.go @@ -24,7 +24,7 @@ func TestMain(m *testing.M) { os.Exit(m.Run()) } -type testFn func(height int64, raw []byte) (map[string]interface{}, error) +type testFn func(network string, height int64, raw []byte) (map[string]interface{}, error) func TestResurrect(t *testing.T) { tests, err := tools.LoadTestData[map[string]any]("Resurrect", expected) @@ -67,7 +67,7 @@ func TestGetStorageAt(t *testing.T) { if trace.Msg == nil { continue } - result, err := evm.GetStorageAt(tt.Height, trace.Msg.Params, trace.MsgRct.Return) + result, err := evm.GetStorageAt(tt.Network, tt.Height, trace.Msg.Params, trace.MsgRct.Return) require.NoError(t, err) require.True(t, tools.CompareResult(result, tt.Expected)) } @@ -88,7 +88,7 @@ func TestInvokeContract(t *testing.T) { if trace.Msg == nil { continue } - result, err := evm.InvokeContract(trace.Msg.Params, trace.MsgRct.Return) + result, err := evm.InvokeContract(tt.Network, tt.Height, trace.Msg.Params, trace.MsgRct.Return) require.NoError(t, err) require.True(t, tools.CompareResult(result, tt.Expected)) } @@ -109,7 +109,7 @@ func TestInvokeContractDelegate(t *testing.T) { if trace.Msg == nil { continue } - result, err := evm.InvokeContractDelegate(tt.Height, trace.Msg.Params, trace.MsgRct.Return) + result, err := evm.InvokeContractDelegate(tt.Network, tt.Height, trace.Msg.Params, trace.MsgRct.Return) require.NoError(t, err) require.True(t, tools.CompareResult(result, tt.Expected)) } @@ -127,7 +127,7 @@ func runTest(t *testing.T, fn testFn, tests []tools.TestCase[map[string]any]) { if trace.Msg == nil { continue } - result, err := fn(tt.Height, trace.Msg.Params) + result, err := fn(tt.Network, tt.Height, trace.Msg.Params) require.NoError(t, err) require.True(t, tools.CompareResult(result, tt.Expected)) } diff --git a/actors/init/init.go b/actors/init/init.go index 8e5c0d8c..ce941b7e 100644 --- a/actors/init/init.go +++ b/actors/init/init.go @@ -17,67 +17,67 @@ import ( "github.com/zondax/fil-parser/types" ) -func InitConstructor(height int64, raw []byte) (map[string]interface{}, error) { +func InitConstructor(network string, height int64, raw []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return initConstructor[*builtinInitv15.ConstructorParams](raw) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return initConstructor[*builtinInitv14.ConstructorParams](raw) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return initConstructor[*builtinInitv13.ConstructorParams](raw) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return initConstructor[*builtinInitv12.ConstructorParams](raw) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return initConstructor[*builtinInitv11.ConstructorParams](raw) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return initConstructor[*builtinInitv10.ConstructorParams](raw) - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return initConstructor[*builtinInitv9.ConstructorParams](raw) - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return initConstructor[*builtinInitv8.ConstructorParams](raw) } return nil, fmt.Errorf("unsupported height: %d", height) } -func ParseExec(height int64, msg *parser.LotusMessage, raw []byte) (map[string]interface{}, *types.AddressInfo, error) { +func ParseExec(network string, height int64, msg *parser.LotusMessage, raw []byte) (map[string]interface{}, *types.AddressInfo, error) { switch { - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parseExec[*builtinInitv15.ExecParams, *builtinInitv15.ExecReturn](msg, raw) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parseExec[*builtinInitv14.ExecParams, *builtinInitv14.ExecReturn](msg, raw) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parseExec[*builtinInitv13.ExecParams, *builtinInitv13.ExecReturn](msg, raw) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parseExec[*builtinInitv12.ExecParams, *builtinInitv12.ExecReturn](msg, raw) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parseExec[*builtinInitv11.ExecParams, *builtinInitv11.ExecReturn](msg, raw) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parseExec[*builtinInitv10.ExecParams, *builtinInitv10.ExecReturn](msg, raw) - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return parseExec[*builtinInitv9.ExecParams, *builtinInitv9.ExecReturn](msg, raw) - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return parseExec[*builtinInitv8.ExecParams, *builtinInitv8.ExecReturn](msg, raw) } return nil, nil, fmt.Errorf("unsupported height: %d", height) } -func ParseExec4(height int64, msg *parser.LotusMessage, raw []byte) (map[string]interface{}, *types.AddressInfo, error) { +func ParseExec4(network string, height int64, msg *parser.LotusMessage, raw []byte) (map[string]interface{}, *types.AddressInfo, error) { switch { - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parseExec[*builtinInitv15.Exec4Params, *builtinInitv15.Exec4Return](msg, raw) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parseExec[*builtinInitv14.Exec4Params, *builtinInitv14.Exec4Return](msg, raw) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parseExec[*builtinInitv13.Exec4Params, *builtinInitv13.Exec4Return](msg, raw) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parseExec[*builtinInitv12.Exec4Params, *builtinInitv12.Exec4Return](msg, raw) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parseExec[*builtinInitv11.Exec4Params, *builtinInitv11.Exec4Return](msg, raw) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parseExec[*builtinInitv10.Exec4Params, *builtinInitv10.Exec4Return](msg, raw) - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return nil, nil, fmt.Errorf("unsupported height: %d", height) - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return nil, nil, fmt.Errorf("unsupported height: %d", height) } return nil, nil, fmt.Errorf("unsupported height: %d", height) diff --git a/actors/init/int_test.go b/actors/init/int_test.go index b8af1136..af7e3d37 100644 --- a/actors/init/int_test.go +++ b/actors/init/int_test.go @@ -26,7 +26,7 @@ func TestMain(m *testing.M) { os.Exit(m.Run()) } -type testFn func(height int64, msg *parser.LotusMessage, raw []byte) (map[string]interface{}, *types.AddressInfo, error) +type testFn func(network string, height int64, msg *parser.LotusMessage, raw []byte) (map[string]interface{}, *types.AddressInfo, error) func TestParseExec(t *testing.T) { tests, err := tools.LoadTestData[map[string]any]("ParseExec", expected) @@ -56,7 +56,7 @@ func TestInitConstructor(t *testing.T) { continue } - result, err := initActor.InitConstructor(tt.Height, trace.Msg.Params) + result, err := initActor.InitConstructor(tt.Network, tt.Height, trace.Msg.Params) require.NoError(t, err) require.True(t, tools.CompareResult(result, tt.Expected)) } @@ -80,7 +80,7 @@ func runTest(t *testing.T, fn testFn, tests []tools.TestCase[map[string]any]) { From: trace.Msg.From, Method: trace.Msg.Method, } - result, address, err := fn(tt.Height, lotusMsg, trace.Msg.Params) + result, address, err := fn(tt.Network, tt.Height, lotusMsg, trace.Msg.Params) require.NoError(t, err) require.True(t, tools.CompareResult(result, tt.Expected)) require.Equal(t, address, tt.Address) diff --git a/actors/market/market.go b/actors/market/market.go index 47497b0b..5793ee2b 100644 --- a/actors/market/market.go +++ b/actors/market/market.go @@ -15,391 +15,340 @@ import ( "github.com/zondax/fil-parser/tools" ) -func ParseAddBalance(height int64, rawParams []byte) (map[string]interface{}, error) { +func ParseAddBalance(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parseGeneric[*address.Address, *address.Address](rawParams, nil, false) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parseGeneric[*address.Address, *address.Address](rawParams, nil, false) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parseGeneric[*address.Address, *address.Address](rawParams, nil, false) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parseGeneric[*address.Address, *address.Address](rawParams, nil, false) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parseGeneric[*address.Address, *address.Address](rawParams, nil, false) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parseGeneric[*address.Address, *address.Address](rawParams, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) } -func ParseWithdrawBalance(height int64, rawParams []byte) (map[string]interface{}, error) { + +func ParseWithdrawBalance(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parseGeneric[*v15Market.WithdrawBalanceParams, *v15Market.WithdrawBalanceParams](rawParams, nil, false) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parseGeneric[*v14Market.WithdrawBalanceParams, *v14Market.WithdrawBalanceParams](rawParams, nil, false) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parseGeneric[*v13Market.WithdrawBalanceParams, *v13Market.WithdrawBalanceParams](rawParams, nil, false) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parseGeneric[*v12Market.WithdrawBalanceParams, *v12Market.WithdrawBalanceParams](rawParams, nil, false) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parseGeneric[*v11Market.WithdrawBalanceParams, *v11Market.WithdrawBalanceParams](rawParams, nil, false) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parseGeneric[*v10Market.WithdrawBalanceParams, *v10Market.WithdrawBalanceParams](rawParams, nil, false) - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return parseGeneric[*v9Market.WithdrawBalanceParams, *v9Market.WithdrawBalanceParams](rawParams, nil, false) - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return parseGeneric[*v8Market.WithdrawBalanceParams, *v8Market.WithdrawBalanceParams](rawParams, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) } -func PublishStorageDealsParams(height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { +func PublishStorageDealsParams(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parseGeneric[*v15Market.PublishStorageDealsParams, *v15Market.PublishStorageDealsReturn](rawParams, rawReturn, true) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parseGeneric[*v14Market.PublishStorageDealsParams, *v14Market.PublishStorageDealsReturn](rawParams, rawReturn, true) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parseGeneric[*v13Market.PublishStorageDealsParams, *v13Market.PublishStorageDealsReturn](rawParams, rawReturn, true) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parseGeneric[*v12Market.PublishStorageDealsParams, *v12Market.PublishStorageDealsReturn](rawParams, rawReturn, true) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parseGeneric[*v11Market.PublishStorageDealsParams, *v11Market.PublishStorageDealsReturn](rawParams, rawReturn, true) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parseGeneric[*v10Market.PublishStorageDealsParams, *v10Market.PublishStorageDealsReturn](rawParams, rawReturn, true) - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return parseGeneric[*v9Market.PublishStorageDealsParams, *v9Market.PublishStorageDealsReturn](rawParams, rawReturn, true) - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return parseGeneric[*v8Market.PublishStorageDealsParams, *v8Market.PublishStorageDealsReturn](rawParams, rawReturn, true) } return nil, fmt.Errorf("unsupported height: %d", height) } -func VerifyDealsForActivationParams(height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { + +func VerifyDealsForActivationParams(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parseGeneric[*v15Market.VerifyDealsForActivationParams, *v15Market.VerifyDealsForActivationReturn](rawParams, rawReturn, true) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parseGeneric[*v14Market.VerifyDealsForActivationParams, *v14Market.VerifyDealsForActivationReturn](rawParams, rawReturn, true) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parseGeneric[*v13Market.VerifyDealsForActivationParams, *v13Market.VerifyDealsForActivationReturn](rawParams, rawReturn, true) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parseGeneric[*v12Market.VerifyDealsForActivationParams, *v12Market.VerifyDealsForActivationReturn](rawParams, rawReturn, true) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parseGeneric[*v11Market.VerifyDealsForActivationParams, *v11Market.VerifyDealsForActivationReturn](rawParams, rawReturn, true) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parseGeneric[*v10Market.VerifyDealsForActivationParams, *v10Market.VerifyDealsForActivationReturn](rawParams, rawReturn, true) - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return parseGeneric[*v9Market.VerifyDealsForActivationParams, *v9Market.VerifyDealsForActivationReturn](rawParams, rawReturn, true) - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return parseGeneric[*v8Market.VerifyDealsForActivationParams, *v8Market.VerifyDealsForActivationReturn](rawParams, rawReturn, true) } return nil, fmt.Errorf("unsupported height: %d", height) } -func ActivateDealsParams(height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { +func ActivateDealsParams(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parseGeneric[*v15Market.ActivateDealsParams, *v15Market.ActivateDealsResult](rawParams, rawReturn, true) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parseGeneric[*v14Market.ActivateDealsParams, *v14Market.ActivateDealsResult](rawParams, rawReturn, true) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parseGeneric[*v13Market.ActivateDealsParams, *v13Market.ActivateDealsResult](rawParams, rawReturn, true) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parseGeneric[*v12Market.ActivateDealsParams, *v12Market.ActivateDealsResult](rawParams, rawReturn, true) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parseGeneric[*v11Market.ActivateDealsParams, *v11Market.ActivateDealsResult](rawParams, rawReturn, true) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parseGeneric[*v10Market.ActivateDealsParams, *v10Market.ActivateDealsResult](rawParams, rawReturn, true) - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return parseGeneric[*v9Market.ActivateDealsParams, *v9Market.ActivateDealsResult](rawParams, rawReturn, true) - // case 8: // This case is commented out in the original code - // return parseGeneric[*v8Market.ActivateDealsParams, *v8Market.ActivateDealsResult](rawParams, rawReturn, true) } return nil, fmt.Errorf("unsupported height: %d", height) } -func OnMinerSectorsTerminateParams(height int64, rawParams []byte) (map[string]interface{}, error) { +func OnMinerSectorsTerminateParams(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parseGeneric[*v15Market.OnMinerSectorsTerminateParams, *v15Market.OnMinerSectorsTerminateParams](rawParams, nil, false) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parseGeneric[*v14Market.OnMinerSectorsTerminateParams, *v14Market.OnMinerSectorsTerminateParams](rawParams, nil, false) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parseGeneric[*v13Market.OnMinerSectorsTerminateParams, *v13Market.OnMinerSectorsTerminateParams](rawParams, nil, false) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parseGeneric[*v12Market.OnMinerSectorsTerminateParams, *v12Market.OnMinerSectorsTerminateParams](rawParams, nil, false) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parseGeneric[*v11Market.OnMinerSectorsTerminateParams, *v11Market.OnMinerSectorsTerminateParams](rawParams, nil, false) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parseGeneric[*v10Market.OnMinerSectorsTerminateParams, *v10Market.OnMinerSectorsTerminateParams](rawParams, nil, false) - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return parseGeneric[*v9Market.OnMinerSectorsTerminateParams, *v9Market.OnMinerSectorsTerminateParams](rawParams, nil, false) - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return parseGeneric[*v8Market.OnMinerSectorsTerminateParams, *v8Market.OnMinerSectorsTerminateParams](rawParams, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) } -func ComputeDataCommitmentParams(height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { +func ComputeDataCommitmentParams(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { switch { - // case 15: // These cases are commented out in the original code - // return parseGeneric[*v15Market.ComputeDataCommitmentParams, *v15Market.ComputeDataCommitmentReturn](rawParams, rawReturn, true) - // case 14: - // return parseGeneric[*v14Market.ComputeDataCommitmentParams, *v14Market.ComputeDataCommitmentReturn](rawParams, rawReturn, true) - // case 13: - // return parseGeneric[*v13Market.ComputeDataCommitmentParams, *v13Market.ComputeDataCommitmentReturn](rawParams, rawReturn, true) - // case 12: - // return parseGeneric[*v12Market.ComputeDataCommitmentParams, *v12Market.ComputeDataCommitmentReturn](rawParams, rawReturn, true) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parseGeneric[*v11Market.ComputeDataCommitmentParams, *v11Market.ComputeDataCommitmentReturn](rawParams, rawReturn, true) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parseGeneric[*v10Market.ComputeDataCommitmentParams, *v10Market.ComputeDataCommitmentReturn](rawParams, rawReturn, true) - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return parseGeneric[*v9Market.ComputeDataCommitmentParams, *v9Market.ComputeDataCommitmentReturn](rawParams, rawReturn, true) - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return parseGeneric[*v8Market.ComputeDataCommitmentParams, *v8Market.ComputeDataCommitmentReturn](rawParams, rawReturn, true) } return nil, fmt.Errorf("unsupported height: %d", height) } -func GetBalanceParams(height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { +func GetBalanceParams(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parseGeneric[*address.Address, *v15Market.GetBalanceReturn](rawParams, rawReturn, true) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parseGeneric[*address.Address, *v14Market.GetBalanceReturn](rawParams, rawReturn, true) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parseGeneric[*address.Address, *v13Market.GetBalanceReturn](rawParams, rawReturn, true) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parseGeneric[*address.Address, *v12Market.GetBalanceReturn](rawParams, rawReturn, true) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parseGeneric[*address.Address, *v11Market.GetBalanceReturn](rawParams, rawReturn, true) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parseGeneric[*address.Address, *v10Market.GetBalanceReturn](rawParams, rawReturn, true) - // case 9: // These cases are commented out in the original code - // return parseGeneric[*address.Address, *v9Market.GetBalanceReturn](rawParams, rawReturn, true) - // case 8: - // return parseGeneric[*address.Address, *v8Market.GetBalanceReturn](rawParams, rawReturn, true) } return nil, fmt.Errorf("unsupported height: %d", height) } -func GetDealDataCommitmentParams(height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { +func GetDealDataCommitmentParams(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parseGeneric[*v15Market.GetDealDataCommitmentParams, *v15Market.GetDealDataCommitmentReturn](rawParams, rawReturn, true) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parseGeneric[*v14Market.GetDealDataCommitmentParams, *v14Market.GetDealDataCommitmentReturn](rawParams, rawReturn, true) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parseGeneric[*v13Market.GetDealDataCommitmentParams, *v13Market.GetDealDataCommitmentReturn](rawParams, rawReturn, true) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parseGeneric[*v12Market.GetDealDataCommitmentParams, *v12Market.GetDealDataCommitmentReturn](rawParams, rawReturn, true) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parseGeneric[*v11Market.GetDealDataCommitmentParams, *v11Market.GetDealDataCommitmentReturn](rawParams, rawReturn, true) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parseGeneric[*v10Market.GetDealDataCommitmentParams, *v10Market.GetDealDataCommitmentReturn](rawParams, rawReturn, true) - // case 9: // These cases are commented out in the original code - // return parseGeneric[*v9Market.GetDealDataCommitmentParams, *v9Market.GetDealDataCommitmentReturn](rawParams, rawReturn, true) - // case 8: - // return parseGeneric[*v8Market.GetDealDataCommitmentParams, *v8Market.GetDealDataCommitmentReturn](rawParams, rawReturn, true) } return nil, fmt.Errorf("unsupported height: %d", height) } -func GetDealClientParams(height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { +func GetDealClientParams(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parseGeneric[*v15Market.GetDealClientParams, *v15Market.GetDealClientReturn](rawParams, rawReturn, true) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parseGeneric[*v14Market.GetDealClientParams, *v14Market.GetDealClientReturn](rawParams, rawReturn, true) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parseGeneric[*v13Market.GetDealClientParams, *v13Market.GetDealClientReturn](rawParams, rawReturn, true) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parseGeneric[*v12Market.GetDealClientParams, *v12Market.GetDealClientReturn](rawParams, rawReturn, true) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parseGeneric[*v11Market.GetDealClientParams, *v11Market.GetDealClientReturn](rawParams, rawReturn, true) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parseGeneric[*v10Market.GetDealClientParams, *v10Market.GetDealClientReturn](rawParams, rawReturn, true) - // case 9: // These cases are commented out in the original code - // return parseGeneric[*v9Market.GetDealClientParams, *v9Market.GetDealClientReturn](rawParams, rawReturn, true) - // case 8: - // return parseGeneric[*v8Market.GetDealClientParams, *v8Market.GetDealClientReturn](rawParams, rawReturn, true) } return nil, fmt.Errorf("unsupported height: %d", height) } -func GetDealProviderParams(height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { +func GetDealProviderParams(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parseGeneric[*v15Market.GetDealProviderParams, *v15Market.GetDealProviderReturn](rawParams, rawReturn, true) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parseGeneric[*v14Market.GetDealProviderParams, *v14Market.GetDealProviderReturn](rawParams, rawReturn, true) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parseGeneric[*v13Market.GetDealProviderParams, *v13Market.GetDealProviderReturn](rawParams, rawReturn, true) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parseGeneric[*v12Market.GetDealProviderParams, *v12Market.GetDealProviderReturn](rawParams, rawReturn, true) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parseGeneric[*v11Market.GetDealProviderParams, *v11Market.GetDealProviderReturn](rawParams, rawReturn, true) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parseGeneric[*v10Market.GetDealProviderParams, *v10Market.GetDealProviderReturn](rawParams, rawReturn, true) - // case 9: // These cases are commented out in the original code - // return parseGeneric[*v9Market.GetDealProviderParams, *v9Market.GetDealProviderReturn](rawParams, rawReturn, true) - // case 8: - // return parseGeneric[*v8Market.GetDealProviderParams, *v8Market.GetDealProviderReturn](rawParams, rawReturn, true) } return nil, fmt.Errorf("unsupported height: %d", height) } -func GetDealLabelParams(height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { +func GetDealLabelParams(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parseGeneric[*v15Market.GetDealLabelParams, *v15Market.GetDealLabelReturn](rawParams, rawReturn, true) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parseGeneric[*v14Market.GetDealLabelParams, *v14Market.GetDealLabelReturn](rawParams, rawReturn, true) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parseGeneric[*v13Market.GetDealLabelParams, *v13Market.GetDealLabelReturn](rawParams, rawReturn, true) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parseGeneric[*v12Market.GetDealLabelParams, *v12Market.GetDealLabelReturn](rawParams, rawReturn, true) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parseGeneric[*v11Market.GetDealLabelParams, *v11Market.GetDealLabelReturn](rawParams, rawReturn, true) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parseGeneric[*v10Market.GetDealLabelParams, *v10Market.GetDealLabelReturn](rawParams, rawReturn, true) - // case 9: // These cases are commented out in the original code - // return parseGeneric[*v9Market.GetDealLabelParams, *v9Market.GetDealLabelReturn](rawParams, rawReturn, true) - // case 8: - // return parseGeneric[*v8Market.GetDealLabelParams, *v8Market.GetDealLabelReturn](rawParams, rawReturn, true) } return nil, fmt.Errorf("unsupported height: %d", height) } -func GetDealTermParams(height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { +func GetDealTermParams(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parseGeneric[*v15Market.GetDealTermParams, *v15Market.GetDealTermReturn](rawParams, rawReturn, true) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parseGeneric[*v14Market.GetDealTermParams, *v14Market.GetDealTermReturn](rawParams, rawReturn, true) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parseGeneric[*v13Market.GetDealTermParams, *v13Market.GetDealTermReturn](rawParams, rawReturn, true) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parseGeneric[*v12Market.GetDealTermParams, *v12Market.GetDealTermReturn](rawParams, rawReturn, true) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parseGeneric[*v11Market.GetDealTermParams, *v11Market.GetDealTermReturn](rawParams, rawReturn, true) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parseGeneric[*v10Market.GetDealTermParams, *v10Market.GetDealTermReturn](rawParams, rawReturn, true) - // case 9: // These cases are commented out in the original code - // return parseGeneric[*v9Market.GetDealTermParams, *v9Market.GetDealTermReturn](rawParams, rawReturn, true) - // case 8: - // return parseGeneric[*v8Market.GetDealTermParams, *v8Market.GetDealTermReturn](rawParams, rawReturn, true) } return nil, fmt.Errorf("unsupported height: %d", height) } -func GetDealTotalPriceParams(height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { +func GetDealTotalPriceParams(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parseGeneric[*v15Market.GetDealTotalPriceParams, *v15Market.GetDealTotalPriceReturn](rawParams, rawReturn, true) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parseGeneric[*v14Market.GetDealTotalPriceParams, *v14Market.GetDealTotalPriceReturn](rawParams, rawReturn, true) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parseGeneric[*v13Market.GetDealTotalPriceParams, *v13Market.GetDealTotalPriceReturn](rawParams, rawReturn, true) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parseGeneric[*v12Market.GetDealTotalPriceParams, *v12Market.GetDealTotalPriceReturn](rawParams, rawReturn, true) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parseGeneric[*v11Market.GetDealTotalPriceParams, *v11Market.GetDealTotalPriceReturn](rawParams, rawReturn, true) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parseGeneric[*v10Market.GetDealTotalPriceParams, *v10Market.GetDealTotalPriceReturn](rawParams, rawReturn, true) - // case 9: // These cases are commented out in the original code - // return parseGeneric[*v9Market.GetDealTotalPriceParams, *v9Market.GetDealTotalPriceReturn](rawParams, rawReturn, true) - // case 8: - // return parseGeneric[*v8Market.GetDealTotalPriceParams, *v8Market.GetDealTotalPriceReturn](rawParams, rawReturn, true) } return nil, fmt.Errorf("unsupported height: %d", height) } -func GetDealClientCollateralParams(height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { +func GetDealClientCollateralParams(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parseGeneric[*v15Market.GetDealClientCollateralParams, *v15Market.GetDealClientCollateralReturn](rawParams, rawReturn, true) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parseGeneric[*v14Market.GetDealClientCollateralParams, *v14Market.GetDealClientCollateralReturn](rawParams, rawReturn, true) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parseGeneric[*v13Market.GetDealClientCollateralParams, *v13Market.GetDealClientCollateralReturn](rawParams, rawReturn, true) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parseGeneric[*v12Market.GetDealClientCollateralParams, *v12Market.GetDealClientCollateralReturn](rawParams, rawReturn, true) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parseGeneric[*v11Market.GetDealClientCollateralParams, *v11Market.GetDealClientCollateralReturn](rawParams, rawReturn, true) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parseGeneric[*v10Market.GetDealClientCollateralParams, *v10Market.GetDealClientCollateralReturn](rawParams, rawReturn, true) - // case 9: // These cases are commented out in the original code - // return parseGeneric[*v9Market.GetDealClientCollateralParams, *v9Market.GetDealClientCollateralReturn](rawParams, rawReturn, true) - // case 8: - // return parseGeneric[*v8Market.GetDealClientCollateralParams, *v8Market.GetDealClientCollateralReturn](rawParams, rawReturn, true) } return nil, fmt.Errorf("unsupported height: %d", height) } -func GetDealProviderCollateralParams(height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { +func GetDealProviderCollateralParams(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parseGeneric[*v15Market.GetDealProviderCollateralParams, *v15Market.GetDealProviderCollateralReturn](rawParams, rawReturn, true) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parseGeneric[*v14Market.GetDealProviderCollateralParams, *v14Market.GetDealProviderCollateralReturn](rawParams, rawReturn, true) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parseGeneric[*v13Market.GetDealProviderCollateralParams, *v13Market.GetDealProviderCollateralReturn](rawParams, rawReturn, true) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parseGeneric[*v12Market.GetDealProviderCollateralParams, *v12Market.GetDealProviderCollateralReturn](rawParams, rawReturn, true) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parseGeneric[*v11Market.GetDealProviderCollateralParams, *v11Market.GetDealProviderCollateralReturn](rawParams, rawReturn, true) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parseGeneric[*v10Market.GetDealProviderCollateralParams, *v10Market.GetDealProviderCollateralReturn](rawParams, rawReturn, true) - // case 9: // These cases are commented out in the original code - // return parseGeneric[*v9Market.GetDealProviderCollateralParams, *v9Market.GetDealProviderCollateralReturn](rawParams, rawReturn, true) - // case 8: - // return parseGeneric[*v8Market.GetDealProviderCollateralParams, *v8Market.GetDealProviderCollateralReturn](rawParams, rawReturn, true) } return nil, fmt.Errorf("unsupported height: %d", height) } -func GetDealVerifiedParams(height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { +func GetDealVerifiedParams(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parseGeneric[*v15Market.GetDealVerifiedParams, *v15Market.GetDealVerifiedReturn](rawParams, rawReturn, true) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parseGeneric[*v14Market.GetDealVerifiedParams, *v14Market.GetDealVerifiedReturn](rawParams, rawReturn, true) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parseGeneric[*v13Market.GetDealVerifiedParams, *v13Market.GetDealVerifiedReturn](rawParams, rawReturn, true) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parseGeneric[*v12Market.GetDealVerifiedParams, *v12Market.GetDealVerifiedReturn](rawParams, rawReturn, true) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parseGeneric[*v11Market.GetDealVerifiedParams, *v11Market.GetDealVerifiedReturn](rawParams, rawReturn, true) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parseGeneric[*v10Market.GetDealVerifiedParams, *v10Market.GetDealVerifiedReturn](rawParams, rawReturn, true) - // case 9: // These cases are commented out in the original code - // return parseGeneric[*v9Market.GetDealVerifiedParams, *v9Market.GetDealVerifiedReturn](rawParams, rawReturn, true) - // case 8: - // return parseGeneric[*v8Market.GetDealVerifiedParams, *v8Market.GetDealVerifiedReturn](rawParams, rawReturn, true) } return nil, fmt.Errorf("unsupported height: %d", height) } -func GetDealActivationParams(height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { +func GetDealActivationParams(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parseGeneric[*v15Market.GetDealActivationParams, *v15Market.GetDealActivationReturn](rawParams, rawReturn, true) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parseGeneric[*v14Market.GetDealActivationParams, *v14Market.GetDealActivationReturn](rawParams, rawReturn, true) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parseGeneric[*v13Market.GetDealActivationParams, *v13Market.GetDealActivationReturn](rawParams, rawReturn, true) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parseGeneric[*v12Market.GetDealActivationParams, *v12Market.GetDealActivationReturn](rawParams, rawReturn, true) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parseGeneric[*v11Market.GetDealActivationParams, *v11Market.GetDealActivationReturn](rawParams, rawReturn, true) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parseGeneric[*v10Market.GetDealActivationParams, *v10Market.GetDealActivationReturn](rawParams, rawReturn, true) - // case 9: // These cases are commented out in the original code - // return parseGeneric[*v9Market.GetDealActivationParams, *v9Market.GetDealActivationReturn](rawParams, rawReturn, true) - // case 8: } return nil, fmt.Errorf("unsupported height: %d", height) } diff --git a/actors/market/market_test.go b/actors/market/market_test.go index 5fbc1d55..d9d9d7ca 100644 --- a/actors/market/market_test.go +++ b/actors/market/market_test.go @@ -24,7 +24,7 @@ func TestMain(m *testing.M) { os.Exit(m.Run()) } -type testFn func(height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) +type testFn func(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) func TestPublishStorageDeals(t *testing.T) { tests, err := tools.LoadTestData[map[string]any]("PublishStorageDealsParams", expected) @@ -166,7 +166,7 @@ func TestOnMinerSectorsTerminate(t *testing.T) { continue } - result, err := market.OnMinerSectorsTerminateParams(tt.Height, trace.Msg.Params) + result, err := market.OnMinerSectorsTerminateParams(tt.Network, tt.Height, trace.Msg.Params) require.NoError(t, err) require.True(t, tools.CompareResult(result, tt.Expected)) } @@ -188,7 +188,7 @@ func TestParseAddBalance(t *testing.T) { continue } - result, err := market.ParseAddBalance(tt.Height, trace.Msg.Params) + result, err := market.ParseAddBalance(tt.Network, tt.Height, trace.Msg.Params) require.NoError(t, err) require.True(t, tools.CompareResult(result, tt.Expected)) } @@ -210,7 +210,7 @@ func TestParseWithdrawBalance(t *testing.T) { continue } - result, err := market.ParseWithdrawBalance(tt.Height, trace.Msg.Params) + result, err := market.ParseWithdrawBalance(tt.Network, tt.Height, trace.Msg.Params) require.NoError(t, err) require.True(t, tools.CompareResult(result, tt.Expected)) } @@ -229,7 +229,7 @@ func runTest(t *testing.T, fn testFn, tests []tools.TestCase[map[string]any]) { continue } - result, err := fn(tt.Height, trace.Msg.Params, trace.MsgRct.Return) + result, err := fn(tt.Network, tt.Height, trace.Msg.Params, trace.MsgRct.Return) require.NoError(t, err) require.True(t, tools.CompareResult(result, tt.Expected)) } diff --git a/actors/miner/address.go b/actors/miner/address.go index f1a35be8..41184641 100644 --- a/actors/miner/address.go +++ b/actors/miner/address.go @@ -15,177 +15,177 @@ import ( "github.com/zondax/fil-parser/tools" ) -func ChangeMultiaddrs(height int64, rawParams []byte) (map[string]interface{}, error) { +func ChangeMultiaddrs(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parseGeneric[*miner15.ChangeMultiaddrsParams, *miner15.ChangeMultiaddrsParams](rawParams, nil, false) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parseGeneric[*miner14.ChangeMultiaddrsParams, *miner14.ChangeMultiaddrsParams](rawParams, nil, false) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parseGeneric[*miner13.ChangeMultiaddrsParams, *miner13.ChangeMultiaddrsParams](rawParams, nil, false) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parseGeneric[*miner12.ChangeMultiaddrsParams, *miner12.ChangeMultiaddrsParams](rawParams, nil, false) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parseGeneric[*miner11.ChangeMultiaddrsParams, *miner11.ChangeMultiaddrsParams](rawParams, nil, false) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parseGeneric[*miner10.ChangeMultiaddrsParams, *miner10.ChangeMultiaddrsParams](rawParams, nil, false) - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return parseGeneric[*miner9.ChangeMultiaddrsParams, *miner9.ChangeMultiaddrsParams](rawParams, nil, false) - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return parseGeneric[*miner8.ChangeMultiaddrsParams, *miner8.ChangeMultiaddrsParams](rawParams, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) } -func ChangePeerID(height int64, rawParams []byte) (map[string]interface{}, error) { +func ChangePeerID(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parseGeneric[*miner15.ChangePeerIDParams, *miner15.ChangePeerIDParams](rawParams, nil, false) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parseGeneric[*miner14.ChangePeerIDParams, *miner14.ChangePeerIDParams](rawParams, nil, false) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parseGeneric[*miner13.ChangePeerIDParams, *miner13.ChangePeerIDParams](rawParams, nil, false) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parseGeneric[*miner12.ChangePeerIDParams, *miner12.ChangePeerIDParams](rawParams, nil, false) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parseGeneric[*miner11.ChangePeerIDParams, *miner11.ChangePeerIDParams](rawParams, nil, false) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parseGeneric[*miner10.ChangePeerIDParams, *miner10.ChangePeerIDParams](rawParams, nil, false) - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return parseGeneric[*miner9.ChangePeerIDParams, *miner9.ChangePeerIDParams](rawParams, nil, false) - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return parseGeneric[*miner8.ChangePeerIDParams, *miner8.ChangePeerIDParams](rawParams, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) } -func ChangeWorkerAddress(height int64, rawParams []byte) (map[string]interface{}, error) { +func ChangeWorkerAddress(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parseGeneric[*miner15.ChangeWorkerAddressParams, *miner15.ChangeWorkerAddressParams](rawParams, nil, false) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parseGeneric[*miner14.ChangeWorkerAddressParams, *miner14.ChangeWorkerAddressParams](rawParams, nil, false) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parseGeneric[*miner13.ChangeWorkerAddressParams, *miner13.ChangeWorkerAddressParams](rawParams, nil, false) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parseGeneric[*miner12.ChangeWorkerAddressParams, *miner12.ChangeWorkerAddressParams](rawParams, nil, false) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parseGeneric[*miner11.ChangeWorkerAddressParams, *miner11.ChangeWorkerAddressParams](rawParams, nil, false) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parseGeneric[*miner10.ChangeWorkerAddressParams, *miner10.ChangeWorkerAddressParams](rawParams, nil, false) - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return parseGeneric[*miner9.ChangeWorkerAddressParams, *miner9.ChangeWorkerAddressParams](rawParams, nil, false) - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return parseGeneric[*miner8.ChangeWorkerAddressParams, *miner8.ChangeWorkerAddressParams](rawParams, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) } -func ChangeOwnerAddress(height int64, rawParams []byte) (map[string]interface{}, error) { +func ChangeOwnerAddress(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parseGeneric[*address.Address, *address.Address](rawParams, nil, false) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parseGeneric[*address.Address, *address.Address](rawParams, nil, false) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parseGeneric[*address.Address, *address.Address](rawParams, nil, false) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parseGeneric[*address.Address, *address.Address](rawParams, nil, false) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parseGeneric[*address.Address, *address.Address](rawParams, nil, false) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parseGeneric[*address.Address, *address.Address](rawParams, nil, false) - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return parseGeneric[*address.Address, *address.Address](rawParams, nil, false) - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return parseGeneric[*address.Address, *address.Address](rawParams, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) } -func IsControllingAddressExported(height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { +func IsControllingAddressExported(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parseGeneric[*miner15.IsControllingAddressParams, *miner15.IsControllingAddressReturn](rawParams, rawReturn, true) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parseGeneric[*miner14.IsControllingAddressParams, *miner14.IsControllingAddressReturn](rawParams, rawReturn, true) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parseGeneric[*miner13.IsControllingAddressParams, *miner13.IsControllingAddressReturn](rawParams, rawReturn, true) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parseGeneric[*miner12.IsControllingAddressParams, *miner12.IsControllingAddressReturn](rawParams, rawReturn, true) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parseGeneric[*miner11.IsControllingAddressParams, *miner11.IsControllingAddressReturn](rawParams, rawReturn, true) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parseGeneric[*miner10.IsControllingAddressParams, *miner10.IsControllingAddressReturn](rawParams, rawReturn, true) - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return nil, fmt.Errorf("not supported") - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return nil, fmt.Errorf("not supported") } return nil, fmt.Errorf("unsupported height: %d", height) } -func GetOwner(height int64, rawReturn []byte) (map[string]interface{}, error) { +func GetOwner(network string, height int64, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parseGeneric[*miner15.GetOwnerReturn, *miner15.GetOwnerReturn](rawReturn, nil, false) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parseGeneric[*miner14.GetOwnerReturn, *miner14.GetOwnerReturn](rawReturn, nil, false) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parseGeneric[*miner13.GetOwnerReturn, *miner13.GetOwnerReturn](rawReturn, nil, false) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parseGeneric[*miner12.GetOwnerReturn, *miner12.GetOwnerReturn](rawReturn, nil, false) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parseGeneric[*miner11.GetOwnerReturn, *miner11.GetOwnerReturn](rawReturn, nil, false) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parseGeneric[*miner10.GetOwnerReturn, *miner10.GetOwnerReturn](rawReturn, nil, false) - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return nil, fmt.Errorf("not supported") - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return nil, fmt.Errorf("not supported") } return nil, fmt.Errorf("unsupported height: %d", height) } -func GetPeerID(height int64, rawReturn []byte) (map[string]interface{}, error) { +func GetPeerID(network string, height int64, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parseGeneric[*miner15.GetPeerIDReturn, *miner15.GetPeerIDReturn](rawReturn, nil, false) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parseGeneric[*miner14.GetPeerIDReturn, *miner14.GetPeerIDReturn](rawReturn, nil, false) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parseGeneric[*miner13.GetPeerIDReturn, *miner13.GetPeerIDReturn](rawReturn, nil, false) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parseGeneric[*miner12.GetPeerIDReturn, *miner12.GetPeerIDReturn](rawReturn, nil, false) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parseGeneric[*miner11.GetPeerIDReturn, *miner11.GetPeerIDReturn](rawReturn, nil, false) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parseGeneric[*miner10.GetPeerIDReturn, *miner10.GetPeerIDReturn](rawReturn, nil, false) - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return nil, fmt.Errorf("not supported") - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return nil, fmt.Errorf("not supported") } return nil, fmt.Errorf("unsupported height: %d", height) } -func GetMultiaddrs(height int64, rawReturn []byte) (map[string]interface{}, error) { +func GetMultiaddrs(network string, height int64, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parseGeneric[*miner15.GetMultiAddrsReturn, *miner15.GetMultiAddrsReturn](rawReturn, nil, false) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parseGeneric[*miner14.GetMultiAddrsReturn, *miner14.GetMultiAddrsReturn](rawReturn, nil, false) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parseGeneric[*miner13.GetMultiAddrsReturn, *miner13.GetMultiAddrsReturn](rawReturn, nil, false) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parseGeneric[*miner12.GetMultiAddrsReturn, *miner12.GetMultiAddrsReturn](rawReturn, nil, false) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parseGeneric[*miner11.GetMultiAddrsReturn, *miner11.GetMultiAddrsReturn](rawReturn, nil, false) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parseGeneric[*miner10.GetMultiAddrsReturn, *miner10.GetMultiAddrsReturn](rawReturn, nil, false) - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return nil, fmt.Errorf("not supported") - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return nil, fmt.Errorf("not supported") } return nil, fmt.Errorf("unsupported height: %d", height) diff --git a/actors/miner/address_test.go b/actors/miner/address_test.go index f79210c1..0d9db678 100644 --- a/actors/miner/address_test.go +++ b/actors/miner/address_test.go @@ -9,7 +9,7 @@ import ( "github.com/zondax/fil-parser/tools" ) -type testFn func(height int64, rawReturn []byte) (map[string]interface{}, error) +type testFn func(network string, height int64, rawReturn []byte) (map[string]interface{}, error) func TestChangeMultiaddrs(t *testing.T) { tests, err := tools.LoadTestData[map[string]any]("ChangeMultiaddrs", expectedData) @@ -67,7 +67,7 @@ func TestIsControllingAddressExported(t *testing.T) { continue } - result, err := miner.IsControllingAddressExported(tt.Height, trace.Msg.Params, trace.MsgRct.Return) + result, err := miner.IsControllingAddressExported(tt.Network, tt.Height, trace.Msg.Params, trace.MsgRct.Return) require.NoError(t, err) require.True(t, tools.CompareResult(result, tt.Expected)) @@ -87,7 +87,7 @@ func runTest(t *testing.T, fn testFn, tests []tools.TestCase[map[string]any]) { continue } - result, err := fn(tt.Height, trace.MsgRct.Return) + result, err := fn(tt.Network, tt.Height, trace.MsgRct.Return) require.NoError(t, err) require.True(t, tools.CompareResult(result, tt.Expected)) diff --git a/actors/miner/balance.go b/actors/miner/balance.go index b5aa6bc7..815863af 100644 --- a/actors/miner/balance.go +++ b/actors/miner/balance.go @@ -14,67 +14,67 @@ import ( "github.com/zondax/fil-parser/tools" ) -func GetAvailableBalance(height int64, rawReturn []byte) (map[string]interface{}, error) { +func GetAvailableBalance(network string, height int64, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parseGeneric[*miner15.GetAvailableBalanceReturn, *miner15.GetAvailableBalanceReturn](rawReturn, nil, false) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parseGeneric[*miner14.GetAvailableBalanceReturn, *miner14.GetAvailableBalanceReturn](rawReturn, nil, false) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parseGeneric[*miner13.GetAvailableBalanceReturn, *miner13.GetAvailableBalanceReturn](rawReturn, nil, false) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parseGeneric[*miner12.GetAvailableBalanceReturn, *miner12.GetAvailableBalanceReturn](rawReturn, nil, false) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parseGeneric[*miner11.GetAvailableBalanceReturn, *miner11.GetAvailableBalanceReturn](rawReturn, nil, false) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parseGeneric[*miner10.GetAvailableBalanceReturn, *miner10.GetAvailableBalanceReturn](rawReturn, nil, false) - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return nil, fmt.Errorf("not supported") - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return nil, fmt.Errorf("not supported") } return nil, fmt.Errorf("unsupported height: %d", height) } -func GetVestingFunds(height int64, rawReturn []byte) (map[string]interface{}, error) { +func GetVestingFunds(network string, height int64, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parseGeneric[*miner15.GetVestingFundsReturn, *miner15.GetVestingFundsReturn](rawReturn, nil, false) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parseGeneric[*miner14.GetVestingFundsReturn, *miner14.GetVestingFundsReturn](rawReturn, nil, false) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parseGeneric[*miner13.GetVestingFundsReturn, *miner13.GetVestingFundsReturn](rawReturn, nil, false) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parseGeneric[*miner12.GetVestingFundsReturn, *miner12.GetVestingFundsReturn](rawReturn, nil, false) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parseGeneric[*miner11.GetVestingFundsReturn, *miner11.GetVestingFundsReturn](rawReturn, nil, false) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parseGeneric[*miner10.GetVestingFundsReturn, *miner10.GetVestingFundsReturn](rawReturn, nil, false) - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return nil, fmt.Errorf("not supported") - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return nil, fmt.Errorf("not supported") } return nil, fmt.Errorf("unsupported height: %d", height) } -func ParseWithdrawBalance(height int64, rawParams []byte) (map[string]interface{}, error) { +func ParseWithdrawBalance(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parseGeneric[*miner15.WithdrawBalanceParams, *miner15.WithdrawBalanceParams](rawParams, nil, false) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parseGeneric[*miner14.WithdrawBalanceParams, *miner14.WithdrawBalanceParams](rawParams, nil, false) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parseGeneric[*miner13.WithdrawBalanceParams, *miner13.WithdrawBalanceParams](rawParams, nil, false) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parseGeneric[*miner12.WithdrawBalanceParams, *miner12.WithdrawBalanceParams](rawParams, nil, false) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parseGeneric[*miner11.WithdrawBalanceParams, *miner11.WithdrawBalanceParams](rawParams, nil, false) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parseGeneric[*miner10.WithdrawBalanceParams, *miner10.WithdrawBalanceParams](rawParams, nil, false) - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return parseGeneric[*miner9.WithdrawBalanceParams, *miner9.WithdrawBalanceParams](rawParams, nil, false) - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return parseGeneric[*miner8.WithdrawBalanceParams, *miner8.WithdrawBalanceParams](rawParams, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) diff --git a/actors/miner/miner.go b/actors/miner/miner.go index 0883e6c8..d80f5d89 100644 --- a/actors/miner/miner.go +++ b/actors/miner/miner.go @@ -14,287 +14,287 @@ import ( "github.com/zondax/fil-parser/tools" ) -func TerminateSectors(height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { +func TerminateSectors(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parseGeneric[*miner15.TerminateSectorsParams, *miner15.TerminateSectorsReturn](rawParams, rawReturn, true) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parseGeneric[*miner14.TerminateSectorsParams, *miner14.TerminateSectorsReturn](rawParams, rawReturn, true) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parseGeneric[*miner13.TerminateSectorsParams, *miner13.TerminateSectorsReturn](rawParams, rawReturn, true) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parseGeneric[*miner12.TerminateSectorsParams, *miner12.TerminateSectorsReturn](rawParams, rawReturn, true) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parseGeneric[*miner11.TerminateSectorsParams, *miner11.TerminateSectorsReturn](rawParams, rawReturn, true) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parseGeneric[*miner10.TerminateSectorsParams, *miner10.TerminateSectorsReturn](rawParams, rawReturn, true) - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return parseGeneric[*miner9.TerminateSectorsParams, *miner9.TerminateSectorsReturn](rawParams, rawReturn, true) - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return parseGeneric[*miner8.TerminateSectorsParams, *miner8.TerminateSectorsReturn](rawParams, rawReturn, true) } return nil, fmt.Errorf("unsupported height: %d", height) } -func DeclareFaults(height int64, rawParams []byte) (map[string]interface{}, error) { +func DeclareFaults(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parseGeneric[*miner15.DeclareFaultsParams, *miner15.DeclareFaultsParams](rawParams, nil, false) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parseGeneric[*miner14.DeclareFaultsParams, *miner14.DeclareFaultsParams](rawParams, nil, false) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parseGeneric[*miner13.DeclareFaultsParams, *miner13.DeclareFaultsParams](rawParams, nil, false) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parseGeneric[*miner12.DeclareFaultsParams, *miner12.DeclareFaultsParams](rawParams, nil, false) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parseGeneric[*miner11.DeclareFaultsParams, *miner11.DeclareFaultsParams](rawParams, nil, false) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parseGeneric[*miner10.DeclareFaultsParams, *miner10.DeclareFaultsParams](rawParams, nil, false) - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return parseGeneric[*miner9.DeclareFaultsParams, *miner9.DeclareFaultsParams](rawParams, nil, false) - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return parseGeneric[*miner8.DeclareFaultsParams, *miner8.DeclareFaultsParams](rawParams, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) } -func DeclareFaultsRecovered(height int64, rawParams []byte) (map[string]interface{}, error) { +func DeclareFaultsRecovered(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parseGeneric[*miner15.DeclareFaultsRecoveredParams, *miner15.DeclareFaultsRecoveredParams](rawParams, nil, false) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parseGeneric[*miner14.DeclareFaultsRecoveredParams, *miner14.DeclareFaultsRecoveredParams](rawParams, nil, false) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parseGeneric[*miner13.DeclareFaultsRecoveredParams, *miner13.DeclareFaultsRecoveredParams](rawParams, nil, false) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parseGeneric[*miner12.DeclareFaultsRecoveredParams, *miner12.DeclareFaultsRecoveredParams](rawParams, nil, false) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parseGeneric[*miner11.DeclareFaultsRecoveredParams, *miner11.DeclareFaultsRecoveredParams](rawParams, nil, false) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parseGeneric[*miner10.DeclareFaultsRecoveredParams, *miner10.DeclareFaultsRecoveredParams](rawParams, nil, false) - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return parseGeneric[*miner9.DeclareFaultsRecoveredParams, *miner9.DeclareFaultsRecoveredParams](rawParams, nil, false) - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return parseGeneric[*miner8.DeclareFaultsRecoveredParams, *miner8.DeclareFaultsRecoveredParams](rawParams, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) } -func ProveReplicaUpdates(height int64, rawParams []byte) (map[string]interface{}, error) { +func ProveReplicaUpdates(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parseGeneric[*miner15.ProveReplicaUpdatesParams, *miner15.ProveReplicaUpdatesParams](rawParams, nil, false) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parseGeneric[*miner14.ProveReplicaUpdatesParams, *miner14.ProveReplicaUpdatesParams](rawParams, nil, false) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parseGeneric[*miner13.ProveReplicaUpdatesParams, *miner13.ProveReplicaUpdatesParams](rawParams, nil, false) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parseGeneric[*miner12.ProveReplicaUpdatesParams, *miner12.ProveReplicaUpdatesParams](rawParams, nil, false) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parseGeneric[*miner11.ProveReplicaUpdatesParams, *miner11.ProveReplicaUpdatesParams](rawParams, nil, false) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parseGeneric[*miner10.ProveReplicaUpdatesParams, *miner10.ProveReplicaUpdatesParams](rawParams, nil, false) - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return parseGeneric[*miner9.ProveReplicaUpdatesParams, *miner9.ProveReplicaUpdatesParams](rawParams, nil, false) - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return parseGeneric[*miner8.ProveReplicaUpdatesParams, *miner8.ProveReplicaUpdatesParams](rawParams, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) } -func PreCommitSectorBatch2(height int64, rawParams []byte) (map[string]interface{}, error) { +func PreCommitSectorBatch2(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parseGeneric[*miner15.PreCommitSectorBatchParams2, *miner15.PreCommitSectorBatchParams2](rawParams, nil, false) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parseGeneric[*miner14.PreCommitSectorBatchParams2, *miner14.PreCommitSectorBatchParams2](rawParams, nil, false) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parseGeneric[*miner13.PreCommitSectorBatchParams2, *miner13.PreCommitSectorBatchParams2](rawParams, nil, false) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parseGeneric[*miner12.PreCommitSectorBatchParams2, *miner12.PreCommitSectorBatchParams2](rawParams, nil, false) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parseGeneric[*miner11.PreCommitSectorBatchParams2, *miner11.PreCommitSectorBatchParams2](rawParams, nil, false) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parseGeneric[*miner10.PreCommitSectorBatchParams2, *miner10.PreCommitSectorBatchParams2](rawParams, nil, false) - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return parseGeneric[*miner9.PreCommitSectorBatchParams2, *miner9.PreCommitSectorBatchParams2](rawParams, nil, false) - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return nil, fmt.Errorf("unsupported height: %d", height) } return nil, fmt.Errorf("unsupported height: %d", height) } -func ProveReplicaUpdates2(height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { +func ProveReplicaUpdates2(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parseGeneric[*miner15.ProveReplicaUpdatesParams2, *miner15.ProveReplicaUpdatesParams2](rawParams, rawReturn, true) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parseGeneric[*miner14.ProveReplicaUpdatesParams2, *miner14.ProveReplicaUpdatesParams2](rawParams, rawReturn, true) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parseGeneric[*miner13.ProveReplicaUpdatesParams2, *miner13.ProveReplicaUpdatesParams2](rawParams, rawReturn, true) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parseGeneric[*miner12.ProveReplicaUpdatesParams2, *miner12.ProveReplicaUpdatesParams2](rawParams, rawReturn, true) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parseGeneric[*miner11.ProveReplicaUpdatesParams2, *miner11.ProveReplicaUpdatesParams2](rawParams, rawReturn, true) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parseGeneric[*miner10.ProveReplicaUpdatesParams2, *miner10.ProveReplicaUpdatesParams2](rawParams, rawReturn, true) - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return parseGeneric[*miner9.ProveReplicaUpdatesParams2, *miner9.ProveReplicaUpdatesParams2](rawParams, rawReturn, true) - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return nil, fmt.Errorf("unsupported height: %d", height) } return nil, fmt.Errorf("unsupported height: %d", height) } -func ProveCommitAggregate(height int64, rawParams []byte) (map[string]interface{}, error) { +func ProveCommitAggregate(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parseGeneric[*miner15.ProveCommitAggregateParams, *miner15.ProveCommitAggregateParams](rawParams, nil, false) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parseGeneric[*miner14.ProveCommitAggregateParams, *miner14.ProveCommitAggregateParams](rawParams, nil, false) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parseGeneric[*miner13.ProveCommitAggregateParams, *miner13.ProveCommitAggregateParams](rawParams, nil, false) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parseGeneric[*miner12.ProveCommitAggregateParams, *miner12.ProveCommitAggregateParams](rawParams, nil, false) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parseGeneric[*miner11.ProveCommitAggregateParams, *miner11.ProveCommitAggregateParams](rawParams, nil, false) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parseGeneric[*miner10.ProveCommitAggregateParams, *miner10.ProveCommitAggregateParams](rawParams, nil, false) - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return parseGeneric[*miner9.ProveCommitAggregateParams, *miner9.ProveCommitAggregateParams](rawParams, nil, false) - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return parseGeneric[*miner8.ProveCommitAggregateParams, *miner8.ProveCommitAggregateParams](rawParams, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) } -func DisputeWindowedPoSt(height int64, rawParams []byte) (map[string]interface{}, error) { +func DisputeWindowedPoSt(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parseGeneric[*miner15.DisputeWindowedPoStParams, *miner15.DisputeWindowedPoStParams](rawParams, nil, false) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parseGeneric[*miner14.DisputeWindowedPoStParams, *miner14.DisputeWindowedPoStParams](rawParams, nil, false) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parseGeneric[*miner13.DisputeWindowedPoStParams, *miner13.DisputeWindowedPoStParams](rawParams, nil, false) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parseGeneric[*miner12.DisputeWindowedPoStParams, *miner12.DisputeWindowedPoStParams](rawParams, nil, false) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parseGeneric[*miner11.DisputeWindowedPoStParams, *miner11.DisputeWindowedPoStParams](rawParams, nil, false) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parseGeneric[*miner10.DisputeWindowedPoStParams, *miner10.DisputeWindowedPoStParams](rawParams, nil, false) - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return parseGeneric[*miner9.DisputeWindowedPoStParams, *miner9.DisputeWindowedPoStParams](rawParams, nil, false) - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return parseGeneric[*miner8.DisputeWindowedPoStParams, *miner8.DisputeWindowedPoStParams](rawParams, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) } -func ReportConsensusFault(height int64, rawParams []byte) (map[string]interface{}, error) { +func ReportConsensusFault(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parseGeneric[*miner15.ReportConsensusFaultParams, *miner15.ReportConsensusFaultParams](rawParams, nil, false) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parseGeneric[*miner14.ReportConsensusFaultParams, *miner14.ReportConsensusFaultParams](rawParams, nil, false) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parseGeneric[*miner13.ReportConsensusFaultParams, *miner13.ReportConsensusFaultParams](rawParams, nil, false) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parseGeneric[*miner12.ReportConsensusFaultParams, *miner12.ReportConsensusFaultParams](rawParams, nil, false) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parseGeneric[*miner11.ReportConsensusFaultParams, *miner11.ReportConsensusFaultParams](rawParams, nil, false) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parseGeneric[*miner10.ReportConsensusFaultParams, *miner10.ReportConsensusFaultParams](rawParams, nil, false) - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return parseGeneric[*miner9.ReportConsensusFaultParams, *miner9.ReportConsensusFaultParams](rawParams, nil, false) - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return parseGeneric[*miner8.ReportConsensusFaultParams, *miner8.ReportConsensusFaultParams](rawParams, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) } -func ChangeBeneficiary(height int64, rawParams []byte) (map[string]interface{}, error) { +func ChangeBeneficiary(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parseGeneric[*miner15.ChangeBeneficiaryParams, *miner15.ChangeBeneficiaryParams](rawParams, nil, false) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parseGeneric[*miner14.ChangeBeneficiaryParams, *miner14.ChangeBeneficiaryParams](rawParams, nil, false) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parseGeneric[*miner13.ChangeBeneficiaryParams, *miner13.ChangeBeneficiaryParams](rawParams, nil, false) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parseGeneric[*miner12.ChangeBeneficiaryParams, *miner12.ChangeBeneficiaryParams](rawParams, nil, false) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parseGeneric[*miner11.ChangeBeneficiaryParams, *miner11.ChangeBeneficiaryParams](rawParams, nil, false) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parseGeneric[*miner10.ChangeBeneficiaryParams, *miner10.ChangeBeneficiaryParams](rawParams, nil, false) - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return parseGeneric[*miner9.ChangeBeneficiaryParams, *miner9.ChangeBeneficiaryParams](rawParams, nil, false) - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return nil, fmt.Errorf("not supported") } return nil, fmt.Errorf("unsupported height: %d", height) } -func MinerConstructor(height int64, rawParams []byte) (map[string]interface{}, error) { +func MinerConstructor(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parseGeneric[*miner15.MinerConstructorParams, *miner15.MinerConstructorParams](rawParams, nil, false) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parseGeneric[*miner14.MinerConstructorParams, *miner14.MinerConstructorParams](rawParams, nil, false) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parseGeneric[*miner13.MinerConstructorParams, *miner13.MinerConstructorParams](rawParams, nil, false) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parseGeneric[*miner12.MinerConstructorParams, *miner12.MinerConstructorParams](rawParams, nil, false) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parseGeneric[*miner11.MinerConstructorParams, *miner11.MinerConstructorParams](rawParams, nil, false) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parseGeneric[*miner10.MinerConstructorParams, *miner10.MinerConstructorParams](rawParams, nil, false) - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return parseGeneric[*miner9.MinerConstructorParams, *miner9.MinerConstructorParams](rawParams, nil, false) - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return parseGeneric[*miner8.MinerConstructorParams, *miner8.MinerConstructorParams](rawParams, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) } -func ApplyRewards(height int64, rawParams []byte) (map[string]interface{}, error) { +func ApplyRewards(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parseGeneric[*miner15.ApplyRewardParams, *miner15.ApplyRewardParams](rawParams, nil, false) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parseGeneric[*miner14.ApplyRewardParams, *miner14.ApplyRewardParams](rawParams, nil, false) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parseGeneric[*miner13.ApplyRewardParams, *miner13.ApplyRewardParams](rawParams, nil, false) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parseGeneric[*miner12.ApplyRewardParams, *miner12.ApplyRewardParams](rawParams, nil, false) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parseGeneric[*miner11.ApplyRewardParams, *miner11.ApplyRewardParams](rawParams, nil, false) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parseGeneric[*miner10.ApplyRewardParams, *miner10.ApplyRewardParams](rawParams, nil, false) - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return parseGeneric[*miner9.ApplyRewardParams, *miner9.ApplyRewardParams](rawParams, nil, false) - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return parseGeneric[*miner8.ApplyRewardParams, *miner8.ApplyRewardParams](rawParams, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) } -func OnDeferredCronEvent(height int64, rawParams []byte) (map[string]interface{}, error) { +func OnDeferredCronEvent(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parseGeneric[*miner15.DeferredCronEventParams, *miner15.DeferredCronEventParams](rawParams, nil, false) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parseGeneric[*miner14.DeferredCronEventParams, *miner14.DeferredCronEventParams](rawParams, nil, false) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parseGeneric[*miner13.DeferredCronEventParams, *miner13.DeferredCronEventParams](rawParams, nil, false) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parseGeneric[*miner12.DeferredCronEventParams, *miner12.DeferredCronEventParams](rawParams, nil, false) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parseGeneric[*miner11.DeferredCronEventParams, *miner11.DeferredCronEventParams](rawParams, nil, false) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parseGeneric[*miner10.DeferredCronEventParams, *miner10.DeferredCronEventParams](rawParams, nil, false) - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return parseGeneric[*miner9.DeferredCronEventParams, *miner9.DeferredCronEventParams](rawParams, nil, false) - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return parseGeneric[*miner8.DeferredCronEventParams, *miner8.DeferredCronEventParams](rawParams, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) diff --git a/actors/miner/miner_test.go b/actors/miner/miner_test.go index 6956a8e9..3f9e9a7c 100644 --- a/actors/miner/miner_test.go +++ b/actors/miner/miner_test.go @@ -103,7 +103,7 @@ func TestTerminateSectors(t *testing.T) { continue } - result, err := miner.TerminateSectors(tt.Height, trace.Msg.Params, trace.MsgRct.Return) + result, err := miner.TerminateSectors(tt.Network, tt.Height, trace.Msg.Params, trace.MsgRct.Return) require.NoError(t, err) require.True(t, tools.CompareResult(result, tt.Expected)) @@ -126,7 +126,7 @@ func TestProveReplicaUpdates2(t *testing.T) { continue } - result, err := miner.ProveReplicaUpdates2(tt.Height, trace.Msg.Params, trace.MsgRct.Return) + result, err := miner.ProveReplicaUpdates2(tt.Network, tt.Height, trace.Msg.Params, trace.MsgRct.Return) require.NoError(t, err) require.True(t, tools.CompareResult(result, tt.Expected)) diff --git a/actors/miner/sector.go b/actors/miner/sector.go index ce2793bc..20287586 100644 --- a/actors/miner/sector.go +++ b/actors/miner/sector.go @@ -14,267 +14,248 @@ import ( "github.com/zondax/fil-parser/tools" ) -func ExtendSectorExpiration2(height int64, rawParams []byte) (map[string]interface{}, error) { +func ExtendSectorExpiration2(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parseGeneric[*miner15.ExtendSectorExpiration2Params, *miner15.ExtendSectorExpiration2Params](rawParams, nil, false) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parseGeneric[*miner14.ExtendSectorExpiration2Params, *miner14.ExtendSectorExpiration2Params](rawParams, nil, false) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parseGeneric[*miner13.ExtendSectorExpiration2Params, *miner13.ExtendSectorExpiration2Params](rawParams, nil, false) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parseGeneric[*miner12.ExtendSectorExpiration2Params, *miner12.ExtendSectorExpiration2Params](rawParams, nil, false) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parseGeneric[*miner11.ExtendSectorExpiration2Params, *miner11.ExtendSectorExpiration2Params](rawParams, nil, false) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parseGeneric[*miner10.ExtendSectorExpiration2Params, *miner10.ExtendSectorExpiration2Params](rawParams, nil, false) - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return parseGeneric[*miner9.ExtendSectorExpiration2Params, *miner9.ExtendSectorExpiration2Params](rawParams, nil, false) - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return nil, fmt.Errorf("not supported") } return nil, fmt.Errorf("unsupported height: %d", height) } -func PreCommitSector(height int64, rawParams []byte) (map[string]interface{}, error) { +func PreCommitSector(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parseGeneric[*miner15.PreCommitSectorParams, *miner15.PreCommitSectorParams](rawParams, nil, false) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parseGeneric[*miner14.PreCommitSectorParams, *miner14.PreCommitSectorParams](rawParams, nil, false) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parseGeneric[*miner13.PreCommitSectorParams, *miner13.PreCommitSectorParams](rawParams, nil, false) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parseGeneric[*miner12.PreCommitSectorParams, *miner12.PreCommitSectorParams](rawParams, nil, false) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parseGeneric[*miner11.PreCommitSectorParams, *miner11.PreCommitSectorParams](rawParams, nil, false) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parseGeneric[*miner10.PreCommitSectorParams, *miner10.PreCommitSectorParams](rawParams, nil, false) - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return parseGeneric[*miner9.PreCommitSectorParams, *miner9.PreCommitSectorParams](rawParams, nil, false) - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return parseGeneric[*miner8.PreCommitSectorParams, *miner8.PreCommitSectorParams](rawParams, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) } -func ProveCommitSector(height int64, rawParams []byte) (map[string]interface{}, error) { +func ProveCommitSector(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parseGeneric[*miner15.ProveCommitSectorParams, *miner15.ProveCommitSectorParams](rawParams, nil, false) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parseGeneric[*miner14.ProveCommitSectorParams, *miner14.ProveCommitSectorParams](rawParams, nil, false) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parseGeneric[*miner13.ProveCommitSectorParams, *miner13.ProveCommitSectorParams](rawParams, nil, false) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parseGeneric[*miner12.ProveCommitSectorParams, *miner12.ProveCommitSectorParams](rawParams, nil, false) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parseGeneric[*miner11.ProveCommitSectorParams, *miner11.ProveCommitSectorParams](rawParams, nil, false) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parseGeneric[*miner10.ProveCommitSectorParams, *miner10.ProveCommitSectorParams](rawParams, nil, false) - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return parseGeneric[*miner9.ProveCommitSectorParams, *miner9.ProveCommitSectorParams](rawParams, nil, false) - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return parseGeneric[*miner8.ProveCommitSectorParams, *miner8.ProveCommitSectorParams](rawParams, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) } -func ProveCommitSectors3(height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { +func ProveCommitSectors3(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parseGeneric[*miner15.ProveCommitSectors3Params, *miner15.ProveCommitSectors3Return](rawParams, rawReturn, true) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parseGeneric[*miner14.ProveCommitSectors3Params, *miner14.ProveCommitSectors3Return](rawParams, rawReturn, true) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parseGeneric[*miner13.ProveCommitSectors3Params, *miner13.ProveCommitSectors3Return](rawParams, rawReturn, true) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return nil, fmt.Errorf("not supported") - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return nil, fmt.Errorf("not supported") - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return nil, fmt.Errorf("not supported") - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return nil, fmt.Errorf("not supported") - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return nil, fmt.Errorf("not supported") } return nil, fmt.Errorf("unsupported height: %d", height) } -func SubmitWindowedPoSt(height int64, rawParams []byte) (map[string]interface{}, error) { +func SubmitWindowedPoSt(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parseGeneric[*miner15.SubmitWindowedPoStParams, *miner15.SubmitWindowedPoStParams](rawParams, nil, false) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parseGeneric[*miner14.SubmitWindowedPoStParams, *miner14.SubmitWindowedPoStParams](rawParams, nil, false) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parseGeneric[*miner13.SubmitWindowedPoStParams, *miner13.SubmitWindowedPoStParams](rawParams, nil, false) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parseGeneric[*miner12.SubmitWindowedPoStParams, *miner12.SubmitWindowedPoStParams](rawParams, nil, false) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parseGeneric[*miner11.SubmitWindowedPoStParams, *miner11.SubmitWindowedPoStParams](rawParams, nil, false) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parseGeneric[*miner10.SubmitWindowedPoStParams, *miner10.SubmitWindowedPoStParams](rawParams, nil, false) - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return parseGeneric[*miner9.SubmitWindowedPoStParams, *miner9.SubmitWindowedPoStParams](rawParams, nil, false) - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return parseGeneric[*miner8.SubmitWindowedPoStParams, *miner8.SubmitWindowedPoStParams](rawParams, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) } -func ConfirmSectorProofsValid(height int64, rawParams []byte) (map[string]interface{}, error) { +func ConfirmSectorProofsValid(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return nil, fmt.Errorf("not supported") - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return nil, fmt.Errorf("not supported") - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parseGeneric[*miner13.ConfirmSectorProofsParams, *miner13.ConfirmSectorProofsParams](rawParams, nil, false) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parseGeneric[*miner12.ConfirmSectorProofsParams, *miner12.ConfirmSectorProofsParams](rawParams, nil, false) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parseGeneric[*miner11.ConfirmSectorProofsParams, *miner11.ConfirmSectorProofsParams](rawParams, nil, false) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parseGeneric[*miner10.ConfirmSectorProofsParams, *miner10.ConfirmSectorProofsParams](rawParams, nil, false) - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return parseGeneric[*miner9.ConfirmSectorProofsParams, *miner9.ConfirmSectorProofsParams](rawParams, nil, false) - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return parseGeneric[*miner8.ConfirmSectorProofsParams, *miner8.ConfirmSectorProofsParams](rawParams, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) } -func CheckSectorProven(height int64, rawParams []byte) (map[string]interface{}, error) { +func CheckSectorProven(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parseGeneric[*miner15.CheckSectorProvenParams, *miner15.CheckSectorProvenParams](rawParams, nil, false) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parseGeneric[*miner14.CheckSectorProvenParams, *miner14.CheckSectorProvenParams](rawParams, nil, false) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parseGeneric[*miner13.CheckSectorProvenParams, *miner13.CheckSectorProvenParams](rawParams, nil, false) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parseGeneric[*miner12.CheckSectorProvenParams, *miner12.CheckSectorProvenParams](rawParams, nil, false) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parseGeneric[*miner11.CheckSectorProvenParams, *miner11.CheckSectorProvenParams](rawParams, nil, false) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parseGeneric[*miner10.CheckSectorProvenParams, *miner10.CheckSectorProvenParams](rawParams, nil, false) - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return parseGeneric[*miner9.CheckSectorProvenParams, *miner9.CheckSectorProvenParams](rawParams, nil, false) - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return parseGeneric[*miner8.CheckSectorProvenParams, *miner8.CheckSectorProvenParams](rawParams, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) } -func ExtendSectorExpiration(height int64, rawParams []byte) (map[string]interface{}, error) { +func ExtendSectorExpiration(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parseGeneric[*miner15.ExtendSectorExpirationParams, *miner15.ExtendSectorExpirationParams](rawParams, nil, false) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parseGeneric[*miner14.ExtendSectorExpirationParams, *miner14.ExtendSectorExpirationParams](rawParams, nil, false) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parseGeneric[*miner13.ExtendSectorExpirationParams, *miner13.ExtendSectorExpirationParams](rawParams, nil, false) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parseGeneric[*miner12.ExtendSectorExpirationParams, *miner12.ExtendSectorExpirationParams](rawParams, nil, false) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parseGeneric[*miner11.ExtendSectorExpirationParams, *miner11.ExtendSectorExpirationParams](rawParams, nil, false) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parseGeneric[*miner10.ExtendSectorExpirationParams, *miner10.ExtendSectorExpirationParams](rawParams, nil, false) - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return parseGeneric[*miner9.ExtendSectorExpirationParams, *miner9.ExtendSectorExpirationParams](rawParams, nil, false) - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return parseGeneric[*miner8.ExtendSectorExpirationParams, *miner8.ExtendSectorExpirationParams](rawParams, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) } -func CompactSectorNumbers(height int64, rawParams []byte) (map[string]interface{}, error) { +func CompactSectorNumbers(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parseGeneric[*miner15.CompactSectorNumbersParams, *miner15.CompactSectorNumbersParams](rawParams, nil, false) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parseGeneric[*miner14.CompactSectorNumbersParams, *miner14.CompactSectorNumbersParams](rawParams, nil, false) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parseGeneric[*miner13.CompactSectorNumbersParams, *miner13.CompactSectorNumbersParams](rawParams, nil, false) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parseGeneric[*miner12.CompactSectorNumbersParams, *miner12.CompactSectorNumbersParams](rawParams, nil, false) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parseGeneric[*miner11.CompactSectorNumbersParams, *miner11.CompactSectorNumbersParams](rawParams, nil, false) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parseGeneric[*miner10.CompactSectorNumbersParams, *miner10.CompactSectorNumbersParams](rawParams, nil, false) - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return parseGeneric[*miner9.CompactSectorNumbersParams, *miner9.CompactSectorNumbersParams](rawParams, nil, false) - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return parseGeneric[*miner8.CompactSectorNumbersParams, *miner8.CompactSectorNumbersParams](rawParams, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) } -func CompactPartitions(height int64, rawParams []byte) (map[string]interface{}, error) { +func CompactPartitions(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parseGeneric[*miner15.CompactPartitionsParams, *miner15.CompactPartitionsParams](rawParams, nil, false) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parseGeneric[*miner14.CompactPartitionsParams, *miner14.CompactPartitionsParams](rawParams, nil, false) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parseGeneric[*miner13.CompactPartitionsParams, *miner13.CompactPartitionsParams](rawParams, nil, false) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parseGeneric[*miner12.CompactPartitionsParams, *miner12.CompactPartitionsParams](rawParams, nil, false) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parseGeneric[*miner11.CompactPartitionsParams, *miner11.CompactPartitionsParams](rawParams, nil, false) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parseGeneric[*miner10.CompactPartitionsParams, *miner10.CompactPartitionsParams](rawParams, nil, false) - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return parseGeneric[*miner9.CompactPartitionsParams, *miner9.CompactPartitionsParams](rawParams, nil, false) - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return parseGeneric[*miner8.CompactPartitionsParams, *miner8.CompactPartitionsParams](rawParams, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) } -func PreCommitSectorBatch(height int64, rawParams []byte) (map[string]interface{}, error) { +func PreCommitSectorBatch(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parseGeneric[*miner15.PreCommitSectorBatchParams, *miner15.PreCommitSectorBatchParams](rawParams, nil, false) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parseGeneric[*miner14.PreCommitSectorBatchParams, *miner14.PreCommitSectorBatchParams](rawParams, nil, false) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parseGeneric[*miner13.PreCommitSectorBatchParams, *miner13.PreCommitSectorBatchParams](rawParams, nil, false) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parseGeneric[*miner12.PreCommitSectorBatchParams, *miner12.PreCommitSectorBatchParams](rawParams, nil, false) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parseGeneric[*miner11.PreCommitSectorBatchParams, *miner11.PreCommitSectorBatchParams](rawParams, nil, false) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parseGeneric[*miner10.PreCommitSectorBatchParams, *miner10.PreCommitSectorBatchParams](rawParams, nil, false) - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return parseGeneric[*miner9.PreCommitSectorBatchParams, *miner9.PreCommitSectorBatchParams](rawParams, nil, false) - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return parseGeneric[*miner8.PreCommitSectorBatchParams, *miner8.PreCommitSectorBatchParams](rawParams, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) } -// TODO: miner.GetSectorSizeReturn does not implement UnmarshalCBOR -func GetSectorSize(height int64, rawReturn []byte) (map[string]interface{}, error) { - // switch { - // case tools.V15.IsSupported(height): - // return parseGeneric[*miner15.GetSectorSizeReturn, *miner15.GetSectorSizeReturn](rawReturn, nil, false) - // case tools.V14.IsSupported(height): - // return parseGeneric[*miner14.GetSectorSizeReturn, *miner14.GetSectorSizeReturn](rawReturn, nil, false) - // case tools.V13.IsSupported(height): - // return parseGeneric[*miner13.GetSectorSizeReturn, *miner13.GetSectorSizeReturn](rawReturn, nil, false) - // case tools.V12.IsSupported(height): - // return parseGeneric[*miner12.GetSectorSizeReturn, *miner12.GetSectorSizeReturn](rawReturn, nil, false) - // case tools.V11.IsSupported(height): - // return parseGeneric[*miner11.GetSectorSizeReturn, *miner11.GetSectorSizeReturn](rawReturn, nil, false) - // case tools.V10.IsSupported(height): - // return parseGeneric[*miner10.GetSectorSizeReturn, *miner10.GetSectorSizeReturn](rawReturn, nil, false) - // case tools.V9.IsSupported(height): - // return nil, fmt.Errorf("not supported") - // case tools.V8.IsSupported(height): - // return nil, fmt.Errorf("not supported") - // } +func GetSectorSize(network string, height int64, rawReturn []byte) (map[string]interface{}, error) { return nil, fmt.Errorf("unsupported height: %d", height) } diff --git a/actors/miner/sector_test.go b/actors/miner/sector_test.go index cf9752fe..24bc7881 100644 --- a/actors/miner/sector_test.go +++ b/actors/miner/sector_test.go @@ -89,7 +89,7 @@ func TestProveCommitSectors3(t *testing.T) { continue } - result, err := miner.ProveCommitSectors3(tt.Height, trace.Msg.Params, trace.MsgRct.Return) + result, err := miner.ProveCommitSectors3(tt.Network, tt.Height, trace.Msg.Params, trace.MsgRct.Return) require.NoError(t, err) require.True(t, tools.CompareResult(result, tt.Expected)) diff --git a/actors/multisig/multisig.go b/actors/multisig/multisig.go index bd3b2063..01cee239 100644 --- a/actors/multisig/multisig.go +++ b/actors/multisig/multisig.go @@ -17,177 +17,177 @@ import ( "github.com/zondax/fil-parser/tools" ) -func MsigConstructor(height int64, raw []byte) (map[string]interface{}, error) { +func MsigConstructor(network string, height int64, raw []byte) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return parse[*multisig8.ConstructorParams, []byte](raw, cborUnmarshaller[*multisig8.ConstructorParams]) - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return parse[*multisig9.ConstructorParams, []byte](raw, cborUnmarshaller[*multisig9.ConstructorParams]) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parse[*multisig10.ConstructorParams, []byte](raw, cborUnmarshaller[*multisig10.ConstructorParams]) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parse[*multisig11.ConstructorParams, []byte](raw, cborUnmarshaller[*multisig11.ConstructorParams]) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parse[*multisig12.ConstructorParams, []byte](raw, cborUnmarshaller[*multisig12.ConstructorParams]) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parse[*multisig13.ConstructorParams, []byte](raw, cborUnmarshaller[*multisig13.ConstructorParams]) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parse[*multisig14.ConstructorParams, []byte](raw, cborUnmarshaller[*multisig14.ConstructorParams]) - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parse[*multisig15.ConstructorParams, []byte](raw, cborUnmarshaller[*multisig15.ConstructorParams]) } return map[string]interface{}{}, nil } -func MsigParams(msg *parser.LotusMessage, height int64, key filTypes.TipSetKey, parser ParseFn) (map[string]interface{}, error) { +func MsigParams(network string, msg *parser.LotusMessage, height int64, key filTypes.TipSetKey, parser ParseFn) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return parseWithMsigParser[*multisig8.ConstructorParams, *multisig8.ConstructorParams](msg, height, key, parser, nil, jsonUnmarshaller[*multisig8.ConstructorParams], false) - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return parseWithMsigParser[*multisig9.ConstructorParams, *multisig9.ConstructorParams](msg, height, key, parser, nil, jsonUnmarshaller[*multisig9.ConstructorParams], false) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parseWithMsigParser[*multisig10.ConstructorParams, *multisig10.ConstructorParams](msg, height, key, parser, nil, jsonUnmarshaller[*multisig10.ConstructorParams], false) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parseWithMsigParser[*multisig11.ConstructorParams, *multisig11.ConstructorParams](msg, height, key, parser, nil, jsonUnmarshaller[*multisig11.ConstructorParams], false) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parseWithMsigParser[*multisig12.ConstructorParams, *multisig12.ConstructorParams](msg, height, key, parser, nil, jsonUnmarshaller[*multisig12.ConstructorParams], false) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parseWithMsigParser[*multisig13.ConstructorParams, *multisig13.ConstructorParams](msg, height, key, parser, nil, jsonUnmarshaller[*multisig13.ConstructorParams], false) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parseWithMsigParser[*multisig14.ConstructorParams, *multisig14.ConstructorParams](msg, height, key, parser, nil, jsonUnmarshaller[*multisig14.ConstructorParams], false) - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parseWithMsigParser[*multisig15.ConstructorParams, *multisig15.ConstructorParams](msg, height, key, parser, nil, jsonUnmarshaller[*multisig15.ConstructorParams], false) } return map[string]interface{}{}, nil } -func Approve(msg *parser.LotusMessage, height int64, key filTypes.TipSetKey, rawReturn []byte, parser ParseFn) (map[string]interface{}, error) { +func Approve(network string, msg *parser.LotusMessage, height int64, key filTypes.TipSetKey, rawReturn []byte, parser ParseFn) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return parseWithMsigParser[*multisig8.ApproveReturn, *multisig8.ApproveReturn](msg, height, key, parser, rawReturn, cborUnmarshaller[*multisig8.ApproveReturn], true) - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return parseWithMsigParser[*multisig9.ApproveReturn, *multisig9.ApproveReturn](msg, height, key, parser, rawReturn, cborUnmarshaller[*multisig9.ApproveReturn], true) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parseWithMsigParser[*multisig10.ApproveReturn, *multisig10.ApproveReturn](msg, height, key, parser, rawReturn, cborUnmarshaller[*multisig10.ApproveReturn], true) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parseWithMsigParser[*multisig11.ApproveReturn, *multisig11.ApproveReturn](msg, height, key, parser, rawReturn, cborUnmarshaller[*multisig11.ApproveReturn], true) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parseWithMsigParser[*multisig12.ApproveReturn, *multisig12.ApproveReturn](msg, height, key, parser, rawReturn, cborUnmarshaller[*multisig12.ApproveReturn], true) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parseWithMsigParser[*multisig13.ApproveReturn, *multisig13.ApproveReturn](msg, height, key, parser, rawReturn, cborUnmarshaller[*multisig13.ApproveReturn], true) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parseWithMsigParser[*multisig14.ApproveReturn, *multisig14.ApproveReturn](msg, height, key, parser, rawReturn, cborUnmarshaller[*multisig14.ApproveReturn], true) - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parseWithMsigParser[*multisig15.ApproveReturn, *multisig15.ApproveReturn](msg, height, key, parser, rawReturn, cborUnmarshaller[*multisig15.ApproveReturn], true) } return map[string]interface{}{}, nil } -func Cancel(msg *parser.LotusMessage, height int64, key filTypes.TipSetKey, rawReturn []byte, parser ParseFn) (map[string]interface{}, error) { +func Cancel(network string, msg *parser.LotusMessage, height int64, key filTypes.TipSetKey, rawReturn []byte, parser ParseFn) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return parseWithMsigParser[metadataWithCbor, metadataWithCbor](msg, height, key, parser, rawReturn, noopUnmarshaller[metadataWithCbor], false) - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return parseWithMsigParser[metadataWithCbor, metadataWithCbor](msg, height, key, parser, rawReturn, noopUnmarshaller[metadataWithCbor], false) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parseWithMsigParser[metadataWithCbor, metadataWithCbor](msg, height, key, parser, rawReturn, noopUnmarshaller[metadataWithCbor], false) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parseWithMsigParser[metadataWithCbor, metadataWithCbor](msg, height, key, parser, rawReturn, noopUnmarshaller[metadataWithCbor], false) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parseWithMsigParser[metadataWithCbor, metadataWithCbor](msg, height, key, parser, rawReturn, noopUnmarshaller[metadataWithCbor], false) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parseWithMsigParser[metadataWithCbor, metadataWithCbor](msg, height, key, parser, rawReturn, noopUnmarshaller[metadataWithCbor], false) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parseWithMsigParser[metadataWithCbor, metadataWithCbor](msg, height, key, parser, rawReturn, noopUnmarshaller[metadataWithCbor], false) - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parseWithMsigParser[metadataWithCbor, metadataWithCbor](msg, height, key, parser, rawReturn, noopUnmarshaller[metadataWithCbor], false) } return map[string]interface{}{}, nil } -func RemoveSigner(msg *parser.LotusMessage, height int64, key filTypes.TipSetKey, rawReturn []byte, parser ParseFn) (map[string]interface{}, error) { +func RemoveSigner(network string, msg *parser.LotusMessage, height int64, key filTypes.TipSetKey, rawReturn []byte, parser ParseFn) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return parseWithMsigParser[metadataWithCbor, metadataWithCbor](msg, height, key, parser, rawReturn, noopUnmarshaller[metadataWithCbor], false) - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return parseWithMsigParser[metadataWithCbor, metadataWithCbor](msg, height, key, parser, rawReturn, noopUnmarshaller[metadataWithCbor], false) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parseWithMsigParser[metadataWithCbor, metadataWithCbor](msg, height, key, parser, rawReturn, noopUnmarshaller[metadataWithCbor], false) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parseWithMsigParser[metadataWithCbor, metadataWithCbor](msg, height, key, parser, rawReturn, noopUnmarshaller[metadataWithCbor], false) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parseWithMsigParser[metadataWithCbor, metadataWithCbor](msg, height, key, parser, rawReturn, noopUnmarshaller[metadataWithCbor], false) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parseWithMsigParser[metadataWithCbor, metadataWithCbor](msg, height, key, parser, rawReturn, noopUnmarshaller[metadataWithCbor], false) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parseWithMsigParser[metadataWithCbor, metadataWithCbor](msg, height, key, parser, rawReturn, noopUnmarshaller[metadataWithCbor], false) - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parseWithMsigParser[metadataWithCbor, metadataWithCbor](msg, height, key, parser, rawReturn, noopUnmarshaller[metadataWithCbor], false) } return map[string]interface{}{}, nil } -func ChangeNumApprovalsThreshold(msg *parser.LotusMessage, height int64, key filTypes.TipSetKey, rawReturn []byte, parser ParseFn) (map[string]interface{}, error) { +func ChangeNumApprovalsThreshold(network string, msg *parser.LotusMessage, height int64, key filTypes.TipSetKey, rawReturn []byte, parser ParseFn) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return parse[*multisig8.ChangeNumApprovalsThresholdParams, []byte](rawReturn, cborUnmarshaller[*multisig8.ChangeNumApprovalsThresholdParams]) - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return parse[*multisig9.ChangeNumApprovalsThresholdParams, []byte](rawReturn, cborUnmarshaller[*multisig9.ChangeNumApprovalsThresholdParams]) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parse[*multisig10.ChangeNumApprovalsThresholdParams, []byte](rawReturn, cborUnmarshaller[*multisig10.ChangeNumApprovalsThresholdParams]) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parse[*multisig11.ChangeNumApprovalsThresholdParams, []byte](rawReturn, cborUnmarshaller[*multisig11.ChangeNumApprovalsThresholdParams]) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parse[*multisig12.ChangeNumApprovalsThresholdParams, []byte](rawReturn, cborUnmarshaller[*multisig12.ChangeNumApprovalsThresholdParams]) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parse[*multisig13.ChangeNumApprovalsThresholdParams, []byte](rawReturn, cborUnmarshaller[*multisig13.ChangeNumApprovalsThresholdParams]) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parse[*multisig14.ChangeNumApprovalsThresholdParams, []byte](rawReturn, cborUnmarshaller[*multisig14.ChangeNumApprovalsThresholdParams]) - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parse[*multisig15.ChangeNumApprovalsThresholdParams, []byte](rawReturn, cborUnmarshaller[*multisig15.ChangeNumApprovalsThresholdParams]) } return map[string]interface{}{}, nil } -func LockBalance(msg *parser.LotusMessage, height int64, key filTypes.TipSetKey, rawReturn []byte, parser ParseFn) (map[string]interface{}, error) { +func LockBalance(network string, msg *parser.LotusMessage, height int64, key filTypes.TipSetKey, rawReturn []byte, parser ParseFn) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return parse[*multisig8.LockBalanceParams, []byte](rawReturn, cborUnmarshaller[*multisig8.LockBalanceParams]) - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return parse[*multisig9.LockBalanceParams, []byte](rawReturn, cborUnmarshaller[*multisig9.LockBalanceParams]) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parse[*multisig10.LockBalanceParams, []byte](rawReturn, cborUnmarshaller[*multisig10.LockBalanceParams]) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parse[*multisig11.LockBalanceParams, []byte](rawReturn, cborUnmarshaller[*multisig11.LockBalanceParams]) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parse[*multisig12.LockBalanceParams, []byte](rawReturn, cborUnmarshaller[*multisig12.LockBalanceParams]) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parse[*multisig13.LockBalanceParams, []byte](rawReturn, cborUnmarshaller[*multisig13.LockBalanceParams]) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parse[*multisig14.LockBalanceParams, []byte](rawReturn, cborUnmarshaller[*multisig14.LockBalanceParams]) - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parse[*multisig15.LockBalanceParams, []byte](rawReturn, cborUnmarshaller[*multisig15.LockBalanceParams]) } return map[string]interface{}{}, nil } -func UniversalReceiverHook(msg *parser.LotusMessage, height int64, key filTypes.TipSetKey, rawReturn []byte, parser ParseFn) (map[string]interface{}, error) { +func UniversalReceiverHook(network string, msg *parser.LotusMessage, height int64, key filTypes.TipSetKey, rawReturn []byte, parser ParseFn) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return parse[*abi.CborBytesTransparent, []byte](rawReturn, cborUnmarshaller[*abi.CborBytesTransparent]) - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return parse[*abi.CborBytesTransparent, []byte](rawReturn, cborUnmarshaller[*abi.CborBytesTransparent]) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parse[*abi.CborBytesTransparent, []byte](rawReturn, cborUnmarshaller[*abi.CborBytesTransparent]) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parse[*abi.CborBytesTransparent, []byte](rawReturn, cborUnmarshaller[*abi.CborBytesTransparent]) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parse[*abi.CborBytesTransparent, []byte](rawReturn, cborUnmarshaller[*abi.CborBytesTransparent]) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parse[*abi.CborBytesTransparent, []byte](rawReturn, cborUnmarshaller[*abi.CborBytesTransparent]) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parse[*abi.CborBytesTransparent, []byte](rawReturn, cborUnmarshaller[*abi.CborBytesTransparent]) - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parse[*abi.CborBytesTransparent, []byte](rawReturn, cborUnmarshaller[*abi.CborBytesTransparent]) } return map[string]interface{}{}, nil diff --git a/actors/multisig/multisig_test.go b/actors/multisig/multisig_test.go index 9add4edd..1f519ffc 100644 --- a/actors/multisig/multisig_test.go +++ b/actors/multisig/multisig_test.go @@ -25,7 +25,7 @@ func TestMain(m *testing.M) { m.Run() } -type testFn func(msg *parser.LotusMessage, height int64, key filTypes.TipSetKey, rawReturn []byte, parser multisig.ParseFn) (map[string]interface{}, error) +type testFn func(network string, msg *parser.LotusMessage, height int64, key filTypes.TipSetKey, rawReturn []byte, parser multisig.ParseFn) (map[string]interface{}, error) func TestApprove(t *testing.T) { tests, err := tools.LoadTestData[map[string]any]("Approve", expected) @@ -77,7 +77,7 @@ func TestMsigConstructor(t *testing.T) { continue } - result, err := multisig.MsigConstructor(tt.Height, trace.MsgRct.Return) + result, err := multisig.MsigConstructor(tt.Network, tt.Height, trace.MsgRct.Return) require.NoError(t, err) require.True(t, tools.CompareResult(result, tt.Expected)) @@ -103,7 +103,7 @@ func TestMsigParams(t *testing.T) { From: trace.Msg.From, Method: trace.Msg.Method, } - result, err := multisig.MsigParams(lotusMsg, tt.Height, tt.TipsetKey, func(*parser.LotusMessage, int64, filTypes.TipSetKey) (string, error) { + result, err := multisig.MsigParams(tt.Network, lotusMsg, tt.Height, tt.TipsetKey, func(*parser.LotusMessage, int64, filTypes.TipSetKey) (string, error) { return "", nil }) require.NoError(t, err) @@ -130,7 +130,7 @@ func runTest(t *testing.T, fn testFn, tests []tools.TestCase[map[string]any]) { From: trace.Msg.From, Method: trace.Msg.Method, } - result, err := fn(lotusMsg, tt.Height, tt.TipsetKey, trace.MsgRct.Return, func(*parser.LotusMessage, int64, filTypes.TipSetKey) (string, error) { + result, err := fn(tt.Network, lotusMsg, tt.Height, tt.TipsetKey, trace.MsgRct.Return, func(*parser.LotusMessage, int64, filTypes.TipSetKey) (string, error) { return "", nil }) require.NoError(t, err) diff --git a/actors/multisig/utils.go b/actors/multisig/utils.go index 8d201986..cc6a3677 100644 --- a/actors/multisig/utils.go +++ b/actors/multisig/utils.go @@ -35,7 +35,7 @@ func mapToStruct(m map[string]interface{}, v interface{}) error { return json.Unmarshal(data, v) } -func getApproveReturn(height int64, raw map[string]interface{}) (interface{}, error) { +func getApproveReturn(network string, height int64, raw map[string]interface{}) (interface{}, error) { var params ApproveValue returnRaw, ok := raw["Return"].(map[string]interface{}) @@ -59,49 +59,49 @@ func getApproveReturn(height int64, raw map[string]interface{}) (interface{}, er } switch { - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): params.Return = multisig8.ApproveReturn{ Applied: applied, Code: exitcode.ExitCode(code), Ret: []byte(ret), } - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): params.Return = multisig9.ApproveReturn{ Applied: applied, Code: exitcode.ExitCode(code), Ret: []byte(ret), } - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): params.Return = multisig10.ApproveReturn{ Applied: applied, Code: exitcode.ExitCode(code), Ret: []byte(ret), } - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): params.Return = multisig11.ApproveReturn{ Applied: applied, Code: exitcode.ExitCode(code), Ret: []byte(ret), } - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): params.Return = multisig12.ApproveReturn{ Applied: applied, Code: exitcode.ExitCode(code), Ret: []byte(ret), } - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): params.Return = multisig13.ApproveReturn{ Applied: applied, Code: exitcode.ExitCode(code), Ret: []byte(ret), } - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): params.Return = multisig14.ApproveReturn{ Applied: applied, Code: exitcode.ExitCode(code), Ret: []byte(ret), } - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): params.Return = multisig15.ApproveReturn{ Applied: applied, Code: exitcode.ExitCode(code), @@ -112,7 +112,7 @@ func getApproveReturn(height int64, raw map[string]interface{}) (interface{}, er return params, nil } -func getCancelReturn(height int64, raw map[string]interface{}) (interface{}, error) { +func getCancelReturn(raw map[string]interface{}) (interface{}, error) { paramsStr, ok := raw["Params"].(string) if !ok { return nil, fmt.Errorf("Params not found or not a string") @@ -133,7 +133,7 @@ func getCancelReturn(height int64, raw map[string]interface{}) (interface{}, err return v, nil } -func getChangeNumApprovalsThresholdValue(height int64, raw map[string]interface{}) (interface{}, error) { +func getChangeNumApprovalsThresholdValue(network string, height int64, raw map[string]interface{}) (interface{}, error) { paramsStr, ok := raw["Params"].(map[string]interface{}) if !ok { return nil, fmt.Errorf("Params not found or not a map") @@ -147,35 +147,35 @@ func getChangeNumApprovalsThresholdValue(height int64, raw map[string]interface{ } var v any switch { - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): v = multisig8.ChangeNumApprovalsThresholdParams{ NewThreshold: newValue, } - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): v = multisig9.ChangeNumApprovalsThresholdParams{ NewThreshold: newValue, } - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): v = multisig10.ChangeNumApprovalsThresholdParams{ NewThreshold: newValue, } - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): v = multisig11.ChangeNumApprovalsThresholdParams{ NewThreshold: newValue, } - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): v = multisig12.ChangeNumApprovalsThresholdParams{ NewThreshold: newValue, } - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): v = multisig13.ChangeNumApprovalsThresholdParams{ NewThreshold: newValue, } - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): v = multisig14.ChangeNumApprovalsThresholdParams{ NewThreshold: newValue, } - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): v = multisig15.ChangeNumApprovalsThresholdParams{ NewThreshold: newValue, } diff --git a/actors/multisig/values.go b/actors/multisig/values.go index 3f88e5b2..ce31eada 100644 --- a/actors/multisig/values.go +++ b/actors/multisig/values.go @@ -15,269 +15,269 @@ import ( "github.com/zondax/fil-parser/tools" ) -func ChangeOwnerAddressValue(height int64, txMetadata string) (interface{}, error) { +func ChangeOwnerAddressValue(network string, height int64, txMetadata string) (interface{}, error) { switch { - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return parse[*ChangeOwnerAddressParams, string](txMetadata, jsonUnmarshaller[*ChangeOwnerAddressParams]) - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return parse[*ChangeOwnerAddressParams, string](txMetadata, jsonUnmarshaller[*ChangeOwnerAddressParams]) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parse[*ChangeOwnerAddressParams, string](txMetadata, jsonUnmarshaller[*ChangeOwnerAddressParams]) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parse[*ChangeOwnerAddressParams, string](txMetadata, jsonUnmarshaller[*ChangeOwnerAddressParams]) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parse[*ChangeOwnerAddressParams, string](txMetadata, jsonUnmarshaller[*ChangeOwnerAddressParams]) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parse[*ChangeOwnerAddressParams, string](txMetadata, jsonUnmarshaller[*ChangeOwnerAddressParams]) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parse[*ChangeOwnerAddressParams, string](txMetadata, jsonUnmarshaller[*ChangeOwnerAddressParams]) - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parse[*ChangeOwnerAddressParams, string](txMetadata, jsonUnmarshaller[*ChangeOwnerAddressParams]) } return nil, nil } -func ParseWithdrawBalanceValue(height int64, txMetadata string) (interface{}, error) { +func ParseWithdrawBalanceValue(network string, height int64, txMetadata string) (interface{}, error) { switch { - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return parse[*miner11.WithdrawBalanceParams, string](txMetadata, jsonUnmarshaller[*miner11.WithdrawBalanceParams]) - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return parse[*miner11.WithdrawBalanceParams, string](txMetadata, jsonUnmarshaller[*miner11.WithdrawBalanceParams]) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parse[*miner11.WithdrawBalanceParams, string](txMetadata, jsonUnmarshaller[*miner11.WithdrawBalanceParams]) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parse[*miner11.WithdrawBalanceParams, string](txMetadata, jsonUnmarshaller[*miner11.WithdrawBalanceParams]) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parse[*miner11.WithdrawBalanceParams, string](txMetadata, jsonUnmarshaller[*miner11.WithdrawBalanceParams]) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parse[*miner11.WithdrawBalanceParams, string](txMetadata, jsonUnmarshaller[*miner11.WithdrawBalanceParams]) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parse[*miner11.WithdrawBalanceParams, string](txMetadata, jsonUnmarshaller[*miner11.WithdrawBalanceParams]) - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parse[*miner11.WithdrawBalanceParams, string](txMetadata, jsonUnmarshaller[*miner11.WithdrawBalanceParams]) } return nil, nil } -func ParseInvokeContractValue(height int64, txMetadata string) (interface{}, error) { +func ParseInvokeContractValue(network string, height int64, txMetadata string) (interface{}, error) { switch { - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return parse[*InvokeContractParams, string](txMetadata, jsonUnmarshaller[*InvokeContractParams]) - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return parse[*InvokeContractParams, string](txMetadata, jsonUnmarshaller[*InvokeContractParams]) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parse[*InvokeContractParams, string](txMetadata, jsonUnmarshaller[*InvokeContractParams]) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parse[*InvokeContractParams, string](txMetadata, jsonUnmarshaller[*InvokeContractParams]) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parse[*InvokeContractParams, string](txMetadata, jsonUnmarshaller[*InvokeContractParams]) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parse[*InvokeContractParams, string](txMetadata, jsonUnmarshaller[*InvokeContractParams]) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parse[*InvokeContractParams, string](txMetadata, jsonUnmarshaller[*InvokeContractParams]) - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parse[*InvokeContractParams, string](txMetadata, jsonUnmarshaller[*InvokeContractParams]) } return nil, nil } -func ParseAddSignerValue(height int64, txMetadata string) (interface{}, error) { +func ParseAddSignerValue(network string, height int64, txMetadata string) (interface{}, error) { switch { - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return parse[*multisig11.AddSignerParams, string](txMetadata, jsonUnmarshaller[*multisig11.AddSignerParams]) - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return parse[*multisig9.AddSignerParams, string](txMetadata, jsonUnmarshaller[*multisig9.AddSignerParams]) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parse[*multisig10.AddSignerParams, string](txMetadata, jsonUnmarshaller[*multisig10.AddSignerParams]) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parse[*multisig11.AddSignerParams, string](txMetadata, jsonUnmarshaller[*multisig11.AddSignerParams]) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parse[*multisig12.AddSignerParams, string](txMetadata, jsonUnmarshaller[*multisig12.AddSignerParams]) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parse[*multisig13.AddSignerParams, string](txMetadata, jsonUnmarshaller[*multisig13.AddSignerParams]) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parse[*multisig14.AddSignerParams, string](txMetadata, jsonUnmarshaller[*multisig14.AddSignerParams]) - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parse[*multisig15.AddSignerParams, string](txMetadata, jsonUnmarshaller[*multisig15.AddSignerParams]) } return nil, nil } -func ParseApproveValue(height int64, txMetadata string) (interface{}, error) { +func ParseApproveValue(network string, height int64, txMetadata string) (interface{}, error) { switch { - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): if data, err := parse[metadataWithCbor, string](txMetadata, jsonUnmarshaller[metadataWithCbor]); err != nil { return nil, err } else { - return getApproveReturn(height, data) + return getApproveReturn(network, height, data) } - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): if data, err := parse[metadataWithCbor, string](txMetadata, jsonUnmarshaller[metadataWithCbor]); err != nil { return nil, err } else { - return getApproveReturn(height, data) + return getApproveReturn(network, height, data) } - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): if data, err := parse[metadataWithCbor, string](txMetadata, jsonUnmarshaller[metadataWithCbor]); err != nil { return nil, err } else { - return getApproveReturn(height, data) + return getApproveReturn(network, height, data) } - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): if data, err := parse[metadataWithCbor, string](txMetadata, jsonUnmarshaller[metadataWithCbor]); err != nil { return nil, err } else { - return getApproveReturn(height, data) + return getApproveReturn(network, height, data) } - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): if data, err := parse[metadataWithCbor, string](txMetadata, jsonUnmarshaller[metadataWithCbor]); err != nil { return nil, err } else { - return getApproveReturn(height, data) + return getApproveReturn(network, height, data) } - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): if data, err := parse[metadataWithCbor, string](txMetadata, jsonUnmarshaller[metadataWithCbor]); err != nil { return nil, err } else { - return getApproveReturn(height, data) + return getApproveReturn(network, height, data) } - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): if data, err := parse[metadataWithCbor, string](txMetadata, jsonUnmarshaller[metadataWithCbor]); err != nil { return nil, err } else { - return getApproveReturn(height, data) + return getApproveReturn(network, height, data) } - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): if data, err := parse[metadataWithCbor, string](txMetadata, jsonUnmarshaller[metadataWithCbor]); err != nil { return nil, err } else { - return getApproveReturn(height, data) + return getApproveReturn(network, height, data) } } return nil, nil } -func ParseCancelValue(height int64, txMetadata string) (interface{}, error) { +func ParseCancelValue(network string, height int64, txMetadata string) (interface{}, error) { switch { - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): if data, err := parse[metadataWithCbor, string](txMetadata, jsonUnmarshaller[metadataWithCbor]); err != nil { return nil, err } else { - return getCancelReturn(height, data) + return getCancelReturn(data) } - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): if data, err := parse[metadataWithCbor, string](txMetadata, jsonUnmarshaller[metadataWithCbor]); err != nil { return nil, err } else { - return getCancelReturn(height, data) + return getCancelReturn(data) } - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): if data, err := parse[metadataWithCbor, string](txMetadata, jsonUnmarshaller[metadataWithCbor]); err != nil { return nil, err } else { - return getCancelReturn(height, data) + return getCancelReturn(data) } - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): if data, err := parse[metadataWithCbor, string](txMetadata, jsonUnmarshaller[metadataWithCbor]); err != nil { return nil, err } else { - return getCancelReturn(height, data) + return getCancelReturn(data) } - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): if data, err := parse[metadataWithCbor, string](txMetadata, jsonUnmarshaller[metadataWithCbor]); err != nil { return nil, err } else { - return getCancelReturn(height, data) + return getCancelReturn(data) } - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): if data, err := parse[metadataWithCbor, string](txMetadata, jsonUnmarshaller[metadataWithCbor]); err != nil { return nil, err } else { - return getCancelReturn(height, data) + return getCancelReturn(data) } - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): if data, err := parse[metadataWithCbor, string](txMetadata, jsonUnmarshaller[metadataWithCbor]); err != nil { return nil, err } else { - return getCancelReturn(height, data) + return getCancelReturn(data) } - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): if data, err := parse[metadataWithCbor, string](txMetadata, jsonUnmarshaller[metadataWithCbor]); err != nil { return nil, err } else { - return getCancelReturn(height, data) + return getCancelReturn(data) } } return nil, nil } -func ChangeNumApprovalsThresholdValue(height int64, txMetadata string) (interface{}, error) { +func ChangeNumApprovalsThresholdValue(network string, height int64, txMetadata string) (interface{}, error) { switch { - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return parse[*multisig8.ChangeNumApprovalsThresholdParams, string](txMetadata, jsonUnmarshaller[*multisig8.ChangeNumApprovalsThresholdParams]) - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return parse[*multisig9.ChangeNumApprovalsThresholdParams, string](txMetadata, jsonUnmarshaller[*multisig9.ChangeNumApprovalsThresholdParams]) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parse[*multisig10.ChangeNumApprovalsThresholdParams, string](txMetadata, jsonUnmarshaller[*multisig10.ChangeNumApprovalsThresholdParams]) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parse[*multisig11.ChangeNumApprovalsThresholdParams, string](txMetadata, jsonUnmarshaller[*multisig11.ChangeNumApprovalsThresholdParams]) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parse[*multisig12.ChangeNumApprovalsThresholdParams, string](txMetadata, jsonUnmarshaller[*multisig12.ChangeNumApprovalsThresholdParams]) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parse[*multisig13.ChangeNumApprovalsThresholdParams, string](txMetadata, jsonUnmarshaller[*multisig13.ChangeNumApprovalsThresholdParams]) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parse[*multisig14.ChangeNumApprovalsThresholdParams, string](txMetadata, jsonUnmarshaller[*multisig14.ChangeNumApprovalsThresholdParams]) - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parse[*multisig15.ChangeNumApprovalsThresholdParams, string](txMetadata, jsonUnmarshaller[*multisig15.ChangeNumApprovalsThresholdParams]) } return nil, nil } -func ParseConstructorValue(height int64, txMetadata string) (interface{}, error) { +func ParseConstructorValue(network string, height int64, txMetadata string) (interface{}, error) { switch { - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): if data, err := parse[*multisig8.ConstructorParams, string](txMetadata, jsonUnmarshaller[*multisig8.ConstructorParams]); err != nil { return nil, err } else { return getValue[*multisig8.ConstructorParams](height, data) } - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): if data, err := parse[*multisig9.ConstructorParams, string](txMetadata, jsonUnmarshaller[*multisig9.ConstructorParams]); err != nil { return nil, err } else { return getValue[*multisig9.ConstructorParams](height, data) } - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): if data, err := parse[*multisig10.ConstructorParams, string](txMetadata, jsonUnmarshaller[*multisig10.ConstructorParams]); err != nil { return nil, err } else { return getValue[*multisig10.ConstructorParams](height, data) } - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): if data, err := parse[*multisig11.ConstructorParams, string](txMetadata, jsonUnmarshaller[*multisig11.ConstructorParams]); err != nil { return nil, err } else { return getValue[*multisig11.ConstructorParams](height, data) } - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): if data, err := parse[*multisig12.ConstructorParams, string](txMetadata, jsonUnmarshaller[*multisig12.ConstructorParams]); err != nil { return nil, err } else { return getValue[*multisig12.ConstructorParams](height, data) } - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): if data, err := parse[*multisig13.ConstructorParams, string](txMetadata, jsonUnmarshaller[*multisig13.ConstructorParams]); err != nil { return nil, err } else { return getValue[*multisig13.ConstructorParams](height, data) } - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): if data, err := parse[*multisig14.ConstructorParams, string](txMetadata, jsonUnmarshaller[*multisig14.ConstructorParams]); err != nil { return nil, err } else { return getValue[*multisig14.ConstructorParams](height, data) } - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): if data, err := parse[*multisig15.ConstructorParams, string](txMetadata, jsonUnmarshaller[*multisig15.ConstructorParams]); err != nil { return nil, err } else { @@ -287,51 +287,51 @@ func ParseConstructorValue(height int64, txMetadata string) (interface{}, error) return nil, nil } -func ParseLockBalanceValue(height int64, txMetadata string) (interface{}, error) { +func ParseLockBalanceValue(network string, height int64, txMetadata string) (interface{}, error) { switch { - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): if data, err := parse[*multisig8.LockBalanceParams, string](txMetadata, jsonUnmarshaller[*multisig8.LockBalanceParams]); err != nil { return nil, err } else { return getValue[*multisig8.LockBalanceParams](height, data) } - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): if data, err := parse[*multisig9.LockBalanceParams, string](txMetadata, jsonUnmarshaller[*multisig9.LockBalanceParams]); err != nil { return nil, err } else { return getValue[*multisig9.LockBalanceParams](height, data) } - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): if data, err := parse[*multisig10.LockBalanceParams, string](txMetadata, jsonUnmarshaller[*multisig10.LockBalanceParams]); err != nil { return nil, err } else { return getValue[*multisig10.LockBalanceParams](height, data) } - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): if data, err := parse[*multisig11.LockBalanceParams, string](txMetadata, jsonUnmarshaller[*multisig11.LockBalanceParams]); err != nil { return nil, err } else { return getValue[*multisig11.LockBalanceParams](height, data) } - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): if data, err := parse[*multisig12.LockBalanceParams, string](txMetadata, jsonUnmarshaller[*multisig12.LockBalanceParams]); err != nil { return nil, err } else { return getValue[*multisig12.LockBalanceParams](height, data) } - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): if data, err := parse[*multisig13.LockBalanceParams, string](txMetadata, jsonUnmarshaller[*multisig13.LockBalanceParams]); err != nil { return nil, err } else { return getValue[*multisig13.LockBalanceParams](height, data) } - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): if data, err := parse[*multisig14.LockBalanceParams, string](txMetadata, jsonUnmarshaller[*multisig14.LockBalanceParams]); err != nil { return nil, err } else { return getValue[*multisig14.LockBalanceParams](height, data) } - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): if data, err := parse[*multisig15.LockBalanceParams, string](txMetadata, jsonUnmarshaller[*multisig15.LockBalanceParams]); err != nil { return nil, err } else { @@ -341,51 +341,51 @@ func ParseLockBalanceValue(height int64, txMetadata string) (interface{}, error) return nil, nil } -func ParseRemoveSignerValue(height int64, txMetadata string) (interface{}, error) { +func ParseRemoveSignerValue(network string, height int64, txMetadata string) (interface{}, error) { switch { - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): if data, err := parse[*multisig8.RemoveSignerParams, string](txMetadata, jsonUnmarshaller[*multisig8.RemoveSignerParams]); err != nil { return nil, err } else { return getValue[*multisig8.RemoveSignerParams](height, data) } - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): if data, err := parse[*multisig9.RemoveSignerParams, string](txMetadata, jsonUnmarshaller[*multisig9.RemoveSignerParams]); err != nil { return nil, err } else { return getValue[*multisig9.RemoveSignerParams](height, data) } - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): if data, err := parse[*multisig10.RemoveSignerParams, string](txMetadata, jsonUnmarshaller[*multisig10.RemoveSignerParams]); err != nil { return nil, err } else { return getValue[*multisig10.RemoveSignerParams](height, data) } - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): if data, err := parse[*multisig11.RemoveSignerParams, string](txMetadata, jsonUnmarshaller[*multisig11.RemoveSignerParams]); err != nil { return nil, err } else { return getValue[*multisig11.RemoveSignerParams](height, data) } - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): if data, err := parse[*multisig12.RemoveSignerParams, string](txMetadata, jsonUnmarshaller[*multisig12.RemoveSignerParams]); err != nil { return nil, err } else { return getValue[*multisig12.RemoveSignerParams](height, data) } - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): if data, err := parse[*multisig13.RemoveSignerParams, string](txMetadata, jsonUnmarshaller[*multisig13.RemoveSignerParams]); err != nil { return nil, err } else { return getValue[*multisig13.RemoveSignerParams](height, data) } - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): if data, err := parse[*multisig14.RemoveSignerParams, string](txMetadata, jsonUnmarshaller[*multisig14.RemoveSignerParams]); err != nil { return nil, err } else { return getValue[*multisig14.RemoveSignerParams](height, data) } - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): if data, err := parse[*multisig15.RemoveSignerParams, string](txMetadata, jsonUnmarshaller[*multisig15.RemoveSignerParams]); err != nil { return nil, err } else { @@ -395,51 +395,51 @@ func ParseRemoveSignerValue(height int64, txMetadata string) (interface{}, error return nil, nil } -func ParseSendValue(height int64, txMetadata string) (interface{}, error) { +func ParseSendValue(network string, height int64, txMetadata string) (interface{}, error) { switch { - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return parse[*SendValue, string](txMetadata, jsonUnmarshaller[*SendValue]) - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return parse[*SendValue, string](txMetadata, jsonUnmarshaller[*SendValue]) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parse[*SendValue, string](txMetadata, jsonUnmarshaller[*SendValue]) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parse[*SendValue, string](txMetadata, jsonUnmarshaller[*SendValue]) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parse[*SendValue, string](txMetadata, jsonUnmarshaller[*SendValue]) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parse[*SendValue, string](txMetadata, jsonUnmarshaller[*SendValue]) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parse[*SendValue, string](txMetadata, jsonUnmarshaller[*SendValue]) - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parse[*SendValue, string](txMetadata, jsonUnmarshaller[*SendValue]) } return nil, nil } -func ParseSwapSignerValue(height int64, txMetadata string) (interface{}, error) { +func ParseSwapSignerValue(network string, height int64, txMetadata string) (interface{}, error) { switch { - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return parse[*multisig8.SwapSignerParams, string](txMetadata, jsonUnmarshaller[*multisig8.SwapSignerParams]) - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return parse[*multisig9.SwapSignerParams, string](txMetadata, jsonUnmarshaller[*multisig9.SwapSignerParams]) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parse[*multisig10.SwapSignerParams, string](txMetadata, jsonUnmarshaller[*multisig10.SwapSignerParams]) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parse[*multisig11.SwapSignerParams, string](txMetadata, jsonUnmarshaller[*multisig11.SwapSignerParams]) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parse[*multisig12.SwapSignerParams, string](txMetadata, jsonUnmarshaller[*multisig12.SwapSignerParams]) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parse[*multisig13.SwapSignerParams, string](txMetadata, jsonUnmarshaller[*multisig13.SwapSignerParams]) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parse[*multisig14.SwapSignerParams, string](txMetadata, jsonUnmarshaller[*multisig14.SwapSignerParams]) - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parse[*multisig15.SwapSignerParams, string](txMetadata, jsonUnmarshaller[*multisig15.SwapSignerParams]) } return nil, nil } -func ParseUniversalReceiverHookValue(height int64, txMetadata string) (interface{}, error) { +func ParseUniversalReceiverHookValue(network string, height int64, txMetadata string) (interface{}, error) { var tx TransactionUniversalReceiverHookMetadata err := json.Unmarshal([]byte(txMetadata), &tx) if err != nil { diff --git a/actors/multisig/values_test.go b/actors/multisig/values_test.go index dbf19595..19009b39 100644 --- a/actors/multisig/values_test.go +++ b/actors/multisig/values_test.go @@ -10,7 +10,7 @@ import ( "github.com/zondax/fil-parser/tools" ) -type valueTestFn func(height int64, txMetadata string) (interface{}, error) +type valueTestFn func(network string, height int64, txMetadata string) (interface{}, error) func TestChangeOwnerAddressValue(t *testing.T) { tests, err := tools.LoadTestData[map[string]any]("ChangeOwnerAddressValue", expected) @@ -101,7 +101,7 @@ func runValueTest(t *testing.T, fn valueTestFn, tests []tools.TestCase[map[strin } // TODO: parse whole multisig tx first before calling this function - result, err := fn(tt.Height, string(trace.Msg.Params)) + result, err := fn(tt.Network, tt.Height, string(trace.Msg.Params)) require.NoError(t, err) require.True(t, reflect.DeepEqual(result, tt.Expected)) } diff --git a/actors/multisig/verifier.go b/actors/multisig/verifier.go index 7617c163..a7c2a442 100644 --- a/actors/multisig/verifier.go +++ b/actors/multisig/verifier.go @@ -12,23 +12,23 @@ import ( "github.com/zondax/fil-parser/tools" ) -func AddVerifierValue(height int64, txMetadata string) (interface{}, error) { +func AddVerifierValue(network string, height int64, txMetadata string) (interface{}, error) { switch { - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return parse[*verifreg8.AddVerifierParams, string](txMetadata, jsonUnmarshaller[*verifreg8.AddVerifierParams]) - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return parse[*verifreg9.AddVerifierParams, string](txMetadata, jsonUnmarshaller[*verifreg9.AddVerifierParams]) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parse[*verifreg10.AddVerifierParams, string](txMetadata, jsonUnmarshaller[*verifreg10.AddVerifierParams]) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parse[*verifreg11.AddVerifierParams, string](txMetadata, jsonUnmarshaller[*verifreg11.AddVerifierParams]) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parse[*verifreg12.AddVerifierParams, string](txMetadata, jsonUnmarshaller[*verifreg12.AddVerifierParams]) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parse[*verifreg13.AddVerifierParams, string](txMetadata, jsonUnmarshaller[*verifreg13.AddVerifierParams]) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parse[*verifreg14.AddVerifierParams, string](txMetadata, jsonUnmarshaller[*verifreg14.AddVerifierParams]) - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parse[*verifreg15.AddVerifierParams, string](txMetadata, jsonUnmarshaller[*verifreg15.AddVerifierParams]) } return nil, nil diff --git a/actors/paymentChannel/paymentChannel.go b/actors/paymentChannel/paymentChannel.go index a5d1fefb..c78149cf 100644 --- a/actors/paymentChannel/paymentChannel.go +++ b/actors/paymentChannel/paymentChannel.go @@ -18,45 +18,45 @@ type paymentChannelParams interface { UnmarshalCBOR(io.Reader) error } -func PaymentChannelConstructor(height int64, raw []byte) (map[string]interface{}, error) { +func PaymentChannelConstructor(network string, height int64, raw []byte) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return parse[*paychv8.ConstructorParams](raw) - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return parse[*paychv9.ConstructorParams](raw) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parse[*paychv10.ConstructorParams](raw) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parse[*paychv11.ConstructorParams](raw) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parse[*paychv12.ConstructorParams](raw) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parse[*paychv13.ConstructorParams](raw) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parse[*paychv14.ConstructorParams](raw) - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parse[*paychv15.ConstructorParams](raw) } return nil, nil } -func UpdateChannelState(height int64, raw []byte) (map[string]interface{}, error) { +func UpdateChannelState(network string, height int64, raw []byte) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return parse[*paychv8.UpdateChannelStateParams](raw) - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return parse[*paychv9.UpdateChannelStateParams](raw) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parse[*paychv10.UpdateChannelStateParams](raw) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parse[*paychv11.UpdateChannelStateParams](raw) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parse[*paychv12.UpdateChannelStateParams](raw) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parse[*paychv13.UpdateChannelStateParams](raw) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parse[*paychv14.UpdateChannelStateParams](raw) - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parse[*paychv15.UpdateChannelStateParams](raw) } return nil, nil diff --git a/actors/paymentChannel/paymentChannel_test.go b/actors/paymentChannel/paymentChannel_test.go index e1d8dc63..4b893759 100644 --- a/actors/paymentChannel/paymentChannel_test.go +++ b/actors/paymentChannel/paymentChannel_test.go @@ -22,7 +22,7 @@ func TestMain(m *testing.M) { m.Run() } -type testFn func(height int64, raw []byte) (map[string]interface{}, error) +type testFn func(network string, height int64, raw []byte) (map[string]interface{}, error) type test struct { name string height int64 @@ -53,7 +53,7 @@ func runTest(t *testing.T, fn testFn, tests []tools.TestCase[map[string]any]) { continue } - result, err := fn(tt.Height, trace.Msg.Params) + result, err := fn(tt.Network, tt.Height, trace.Msg.Params) require.NoError(t, err) require.True(t, tools.CompareResult(result, tt.Expected)) diff --git a/actors/power/power.go b/actors/power/power.go index 83c22ba3..e97234d0 100644 --- a/actors/power/power.go +++ b/actors/power/power.go @@ -17,297 +17,297 @@ import ( "github.com/zondax/fil-parser/tools" ) -func CurrentTotalPower(msg *parser.LotusMessage, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { +func CurrentTotalPower(network string, msg *parser.LotusMessage, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): data, _, err := parse[*powerv8.CurrentTotalPowerReturn, *powerv8.CurrentTotalPowerReturn](msg, raw, rawReturn, false) return data, err - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): data, _, err := parse[*powerv9.CurrentTotalPowerReturn, *powerv9.CurrentTotalPowerReturn](msg, raw, rawReturn, false) return data, err - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): data, _, err := parse[*powerv10.CurrentTotalPowerReturn, *powerv10.CurrentTotalPowerReturn](msg, raw, rawReturn, false) return data, err - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): data, _, err := parse[*powerv11.CurrentTotalPowerReturn, *powerv11.CurrentTotalPowerReturn](msg, raw, rawReturn, false) return data, err - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): data, _, err := parse[*powerv12.CurrentTotalPowerReturn, *powerv12.CurrentTotalPowerReturn](msg, raw, rawReturn, false) return data, err - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): data, _, err := parse[*powerv13.CurrentTotalPowerReturn, *powerv13.CurrentTotalPowerReturn](msg, raw, rawReturn, false) return data, err - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): data, _, err := parse[*powerv14.CurrentTotalPowerReturn, *powerv14.CurrentTotalPowerReturn](msg, raw, rawReturn, false) return data, err - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): data, _, err := parse[*powerv15.CurrentTotalPowerReturn, *powerv15.CurrentTotalPowerReturn](msg, raw, rawReturn, false) return data, err } return nil, nil } -func SubmitPoRepForBulkVerify(msg *parser.LotusMessage, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { +func SubmitPoRepForBulkVerify(network string, msg *parser.LotusMessage, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { data, _, err := parse[*proof.SealVerifyInfo, *proof.SealVerifyInfo](msg, raw, rawReturn, false) return data, err } -func PowerConstructor(height int64, msg *parser.LotusMessage, raw []byte) (map[string]interface{}, error) { +func PowerConstructor(network string, height int64, msg *parser.LotusMessage, raw []byte) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): data, _, err := parse[*powerv8.MinerConstructorParams, *powerv8.MinerConstructorParams](msg, raw, nil, false) return data, err - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): data, _, err := parse[*powerv9.MinerConstructorParams, *powerv9.MinerConstructorParams](msg, raw, nil, false) return data, err - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): data, _, err := parse[*powerv10.MinerConstructorParams, *powerv10.MinerConstructorParams](msg, raw, nil, false) return data, err - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): data, _, err := parse[*powerv11.MinerConstructorParams, *powerv11.MinerConstructorParams](msg, raw, nil, false) return data, err - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): data, _, err := parse[*powerv12.MinerConstructorParams, *powerv12.MinerConstructorParams](msg, raw, nil, false) return data, err - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): data, _, err := parse[*powerv13.MinerConstructorParams, *powerv13.MinerConstructorParams](msg, raw, nil, false) return data, err - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): data, _, err := parse[*powerv14.MinerConstructorParams, *powerv14.MinerConstructorParams](msg, raw, nil, false) return data, err - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): data, _, err := parse[*powerv15.MinerConstructorParams, *powerv15.MinerConstructorParams](msg, raw, nil, false) return data, err } return nil, nil } -func CreateMiner(msg *parser.LotusMessage, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { +func CreateMiner(network string, msg *parser.LotusMessage, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): data, _, err := parse[*powerv8.CreateMinerParams, *powerv8.CreateMinerReturn](msg, raw, rawReturn, true) return data, err - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): data, _, err := parse[*powerv9.CreateMinerParams, *powerv9.CreateMinerReturn](msg, raw, rawReturn, true) return data, err - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): data, _, err := parse[*powerv10.CreateMinerParams, *powerv10.CreateMinerReturn](msg, raw, rawReturn, true) return data, err - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): data, _, err := parse[*powerv11.CreateMinerParams, *powerv11.CreateMinerReturn](msg, raw, rawReturn, true) return data, err - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): data, _, err := parse[*powerv12.CreateMinerParams, *powerv12.CreateMinerReturn](msg, raw, rawReturn, true) return data, err - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): data, _, err := parse[*powerv13.CreateMinerParams, *powerv13.CreateMinerReturn](msg, raw, rawReturn, true) return data, err - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): data, _, err := parse[*powerv14.CreateMinerParams, *powerv14.CreateMinerReturn](msg, raw, rawReturn, true) return data, err - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): data, _, err := parse[*powerv15.CreateMinerParams, *powerv15.CreateMinerReturn](msg, raw, rawReturn, true) return data, err } return nil, nil } -func EnrollCronEvent(msg *parser.LotusMessage, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { +func EnrollCronEvent(network string, msg *parser.LotusMessage, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): data, _, err := parse[*powerv8.EnrollCronEventParams, *powerv8.EnrollCronEventParams](msg, raw, rawReturn, true) return data, err - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): data, _, err := parse[*powerv9.EnrollCronEventParams, *powerv9.EnrollCronEventParams](msg, raw, rawReturn, true) return data, err - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): data, _, err := parse[*powerv10.EnrollCronEventParams, *powerv10.EnrollCronEventParams](msg, raw, rawReturn, true) return data, err - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): data, _, err := parse[*powerv11.EnrollCronEventParams, *powerv11.EnrollCronEventParams](msg, raw, rawReturn, true) return data, err - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): data, _, err := parse[*powerv12.EnrollCronEventParams, *powerv12.EnrollCronEventParams](msg, raw, rawReturn, true) return data, err - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): data, _, err := parse[*powerv13.EnrollCronEventParams, *powerv13.EnrollCronEventParams](msg, raw, rawReturn, true) return data, err - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): data, _, err := parse[*powerv14.EnrollCronEventParams, *powerv14.EnrollCronEventParams](msg, raw, rawReturn, true) return data, err - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): data, _, err := parse[*powerv15.EnrollCronEventParams, *powerv15.EnrollCronEventParams](msg, raw, rawReturn, true) return data, err } return nil, nil } -func UpdateClaimedPower(msg *parser.LotusMessage, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { +func UpdateClaimedPower(network string, msg *parser.LotusMessage, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): data, _, err := parse[*powerv8.UpdateClaimedPowerParams, *powerv8.UpdateClaimedPowerParams](msg, raw, rawReturn, true) return data, err - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): data, _, err := parse[*powerv9.UpdateClaimedPowerParams, *powerv9.UpdateClaimedPowerParams](msg, raw, rawReturn, true) return data, err - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): data, _, err := parse[*powerv10.UpdateClaimedPowerParams, *powerv10.UpdateClaimedPowerParams](msg, raw, rawReturn, true) return data, err - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): data, _, err := parse[*powerv11.UpdateClaimedPowerParams, *powerv11.UpdateClaimedPowerParams](msg, raw, rawReturn, true) return data, err - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): data, _, err := parse[*powerv12.UpdateClaimedPowerParams, *powerv12.UpdateClaimedPowerParams](msg, raw, rawReturn, true) return data, err - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): data, _, err := parse[*powerv13.UpdateClaimedPowerParams, *powerv13.UpdateClaimedPowerParams](msg, raw, rawReturn, true) return data, err - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): data, _, err := parse[*powerv14.UpdateClaimedPowerParams, *powerv14.UpdateClaimedPowerParams](msg, raw, rawReturn, true) return data, err - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): data, _, err := parse[*powerv15.UpdateClaimedPowerParams, *powerv15.UpdateClaimedPowerParams](msg, raw, rawReturn, true) return data, err } return nil, nil } -func UpdatePledgeTotal(msg *parser.LotusMessage, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { +func UpdatePledgeTotal(network string, msg *parser.LotusMessage, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): data, _, err := parse[*abi.TokenAmount, *abi.TokenAmount](msg, raw, rawReturn, false) return data, err - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): data, _, err := parse[*abi.TokenAmount, *abi.TokenAmount](msg, raw, rawReturn, false) return data, err - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): data, _, err := parse[*abi.TokenAmount, *abi.TokenAmount](msg, raw, rawReturn, false) return data, err - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): data, _, err := parse[*abi.TokenAmount, *abi.TokenAmount](msg, raw, rawReturn, false) return data, err - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): data, _, err := parse[*abi.TokenAmount, *abi.TokenAmount](msg, raw, rawReturn, false) return data, err - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): data, _, err := parse[*abi.TokenAmount, *abi.TokenAmount](msg, raw, rawReturn, false) return data, err - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): data, _, err := parse[*abi.TokenAmount, *abi.TokenAmount](msg, raw, rawReturn, false) return data, err - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): data, _, err := parse[*abi.TokenAmount, *abi.TokenAmount](msg, raw, rawReturn, false) return data, err } return nil, nil } -func NetworkRawPower(msg *parser.LotusMessage, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { +func NetworkRawPower(network string, msg *parser.LotusMessage, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return nil, fmt.Errorf("not supported") - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return nil, fmt.Errorf("not supported") - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): data, _, err := parse[*powerv10.NetworkRawPowerReturn, *powerv10.NetworkRawPowerReturn](msg, raw, rawReturn, false) return data, err - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): data, _, err := parse[*powerv11.NetworkRawPowerReturn, *powerv11.NetworkRawPowerReturn](msg, raw, rawReturn, false) return data, err - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): data, _, err := parse[*powerv12.NetworkRawPowerReturn, *powerv12.NetworkRawPowerReturn](msg, raw, rawReturn, false) return data, err - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): data, _, err := parse[*powerv13.NetworkRawPowerReturn, *powerv13.NetworkRawPowerReturn](msg, raw, rawReturn, false) return data, err - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): data, _, err := parse[*powerv14.NetworkRawPowerReturn, *powerv14.NetworkRawPowerReturn](msg, raw, rawReturn, false) return data, err - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): data, _, err := parse[*powerv15.NetworkRawPowerReturn, *powerv15.NetworkRawPowerReturn](msg, raw, rawReturn, false) return data, err } return nil, nil } -func MinerRawPower(msg *parser.LotusMessage, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { +func MinerRawPower(network string, msg *parser.LotusMessage, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return nil, fmt.Errorf("not supported") - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return nil, fmt.Errorf("not supported") - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): data, _, err := parse[*powerv10.MinerRawPowerParams, *powerv10.MinerRawPowerReturn](msg, raw, rawReturn, true) return data, err - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): data, _, err := parse[*powerv11.MinerRawPowerParams, *powerv11.MinerRawPowerReturn](msg, raw, rawReturn, true) return data, err - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): data, _, err := parse[*powerv12.MinerRawPowerParams, *powerv12.MinerRawPowerReturn](msg, raw, rawReturn, true) return data, err - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): data, _, err := parse[*powerv13.MinerRawPowerParams, *powerv13.MinerRawPowerReturn](msg, raw, rawReturn, true) return data, err - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): data, _, err := parse[*powerv14.MinerRawPowerParams, *powerv14.MinerRawPowerReturn](msg, raw, rawReturn, true) return data, err - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): data, _, err := parse[*powerv15.MinerRawPowerParams, *powerv15.MinerRawPowerReturn](msg, raw, rawReturn, true) return data, err } return nil, nil } -func MinerCount(msg *parser.LotusMessage, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { +func MinerCount(network string, msg *parser.LotusMessage, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return nil, fmt.Errorf("not supported") - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return nil, fmt.Errorf("not supported") - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): data, _, err := parse[*powerv10.MinerCountReturn, *powerv10.MinerCountReturn](msg, raw, rawReturn, false) return data, err - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): data, _, err := parse[*powerv11.MinerCountReturn, *powerv11.MinerCountReturn](msg, raw, rawReturn, false) return data, err - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): data, _, err := parse[*powerv12.MinerCountReturn, *powerv12.MinerCountReturn](msg, raw, rawReturn, false) return data, err - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): data, _, err := parse[*powerv13.MinerCountReturn, *powerv13.MinerCountReturn](msg, raw, rawReturn, false) return data, err - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): data, _, err := parse[*powerv14.MinerCountReturn, *powerv14.MinerCountReturn](msg, raw, rawReturn, false) return data, err - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): data, _, err := parse[*powerv15.MinerCountReturn, *powerv15.MinerCountReturn](msg, raw, rawReturn, false) return data, err } return nil, nil } -func MinerConsensusCount(msg *parser.LotusMessage, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { +func MinerConsensusCount(network string, msg *parser.LotusMessage, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return nil, fmt.Errorf("not supported") - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return nil, fmt.Errorf("not supported") - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): data, _, err := parse[*powerv10.MinerConsensusCountReturn, *powerv10.MinerConsensusCountReturn](msg, raw, rawReturn, false) return data, err - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): data, _, err := parse[*powerv11.MinerConsensusCountReturn, *powerv11.MinerConsensusCountReturn](msg, raw, rawReturn, false) return data, err - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): data, _, err := parse[*powerv12.MinerConsensusCountReturn, *powerv12.MinerConsensusCountReturn](msg, raw, rawReturn, false) return data, err - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): data, _, err := parse[*powerv13.MinerConsensusCountReturn, *powerv13.MinerConsensusCountReturn](msg, raw, rawReturn, false) return data, err - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): data, _, err := parse[*powerv14.MinerConsensusCountReturn, *powerv14.MinerConsensusCountReturn](msg, raw, rawReturn, false) return data, err - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): data, _, err := parse[*powerv15.MinerConsensusCountReturn, *powerv15.MinerConsensusCountReturn](msg, raw, rawReturn, false) return data, err } diff --git a/actors/power/power_test.go b/actors/power/power_test.go index 95fdcf6e..745b2a92 100644 --- a/actors/power/power_test.go +++ b/actors/power/power_test.go @@ -23,7 +23,7 @@ func TestMain(m *testing.M) { m.Run() } -type testFn func(msg *parser.LotusMessage, height int64, raw, rawReturn []byte) (map[string]interface{}, error) +type testFn func(network string, msg *parser.LotusMessage, height int64, raw, rawReturn []byte) (map[string]interface{}, error) func TestCurrentTotalPower(t *testing.T) { tests, err := tools.LoadTestData[map[string]any]("CurrentTotalPower", expected) @@ -103,7 +103,7 @@ func TestPowerConstructor(t *testing.T) { From: trace.Msg.From, Method: trace.Msg.Method, } - result, err := power.PowerConstructor(tt.Height, lotusMsg, trace.Msg.Params) + result, err := power.PowerConstructor(tt.Network, tt.Height, lotusMsg, trace.Msg.Params) require.NoError(t, err) require.True(t, tools.CompareResult(result, tt.Expected)) } @@ -126,7 +126,7 @@ func runTest(t *testing.T, fn testFn, tests []tools.TestCase[map[string]any]) { From: trace.Msg.From, Method: trace.Msg.Method, } - result, err := fn(lotusMsg, tt.Height, trace.Msg.Params, trace.MsgRct.Return) + result, err := fn(tt.Network, lotusMsg, tt.Height, trace.Msg.Params, trace.MsgRct.Return) require.NoError(t, err) require.True(t, tools.CompareResult(result, tt.Expected)) } diff --git a/actors/reward/reward.go b/actors/reward/reward.go index 18fe6384..89fe3e62 100644 --- a/actors/reward/reward.go +++ b/actors/reward/reward.go @@ -13,53 +13,53 @@ import ( "github.com/zondax/fil-parser/tools" ) -func RewardConstructor(height int64, raw []byte) (map[string]interface{}, error) { +func RewardConstructor(network string, height int64, raw []byte) (map[string]interface{}, error) { return parse[*abi.StoragePower](raw) } -func AwardBlockReward(height int64, raw []byte) (map[string]interface{}, error) { +func AwardBlockReward(network string, height int64, raw []byte) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return parse[*rewardv8.AwardBlockRewardParams](raw) - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return parse[*rewardv9.AwardBlockRewardParams](raw) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parse[*rewardv10.AwardBlockRewardParams](raw) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parse[*rewardv11.AwardBlockRewardParams](raw) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parse[*rewardv12.AwardBlockRewardParams](raw) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parse[*rewardv13.AwardBlockRewardParams](raw) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parse[*rewardv14.AwardBlockRewardParams](raw) - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parse[*rewardv15.AwardBlockRewardParams](raw) } return nil, nil } -func UpdateNetworkKPI(height int64, raw []byte) (map[string]interface{}, error) { +func UpdateNetworkKPI(network string, height int64, raw []byte) (map[string]interface{}, error) { return parse[*abi.StoragePower](raw) } -func ThisEpochReward(height int64, raw []byte) (map[string]interface{}, error) { +func ThisEpochReward(network string, height int64, raw []byte) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return parse[*rewardv8.ThisEpochRewardReturn](raw) - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return parse[*rewardv9.ThisEpochRewardReturn](raw) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parse[*rewardv10.ThisEpochRewardReturn](raw) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parse[*rewardv11.ThisEpochRewardReturn](raw) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parse[*rewardv12.ThisEpochRewardReturn](raw) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parse[*rewardv13.ThisEpochRewardReturn](raw) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parse[*rewardv14.ThisEpochRewardReturn](raw) - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parse[*rewardv15.ThisEpochRewardReturn](raw) } return nil, nil diff --git a/actors/reward/reward_test.go b/actors/reward/reward_test.go index 8c277768..96a9484b 100644 --- a/actors/reward/reward_test.go +++ b/actors/reward/reward_test.go @@ -22,7 +22,7 @@ func TestMain(m *testing.M) { m.Run() } -type testFn func(height int64, raw []byte) (map[string]interface{}, error) +type testFn func(network string, height int64, raw []byte) (map[string]interface{}, error) func TestRewardConstructor(t *testing.T) { tests, err := tools.LoadTestData[map[string]any]("RewardConstructor", expected) @@ -59,7 +59,7 @@ func runTest(t *testing.T, fn testFn, tests []tools.TestCase[map[string]any]) { continue } - result, err := fn(tt.Height, trace.Msg.Params) + result, err := fn(tt.Network, tt.Height, trace.Msg.Params) require.NoError(t, err) require.True(t, tools.CompareResult(result, tt.Expected)) } diff --git a/actors/verifiedRegistry/verifiedRegistry.go b/actors/verifiedRegistry/verifiedRegistry.go index bf51decf..1c473cb5 100644 --- a/actors/verifiedRegistry/verifiedRegistry.go +++ b/actors/verifiedRegistry/verifiedRegistry.go @@ -16,291 +16,291 @@ import ( "github.com/zondax/fil-parser/tools" ) -func AddVerifier(height int64, raw []byte) (map[string]interface{}, error) { +func AddVerifier(network string, height int64, raw []byte) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return parse[*verifregv8.AddVerifierParams, *verifregv8.AddVerifierParams](raw, nil, false) - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return parse[*verifregv9.AddVerifierParams, *verifregv9.AddVerifierParams](raw, nil, false) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parse[*verifregv10.AddVerifierParams, *verifregv10.AddVerifierParams](raw, nil, false) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parse[*verifregv11.AddVerifierParams, *verifregv11.AddVerifierParams](raw, nil, false) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parse[*verifregv12.AddVerifierParams, *verifregv12.AddVerifierParams](raw, nil, false) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parse[*verifregv13.AddVerifierParams, *verifregv13.AddVerifierParams](raw, nil, false) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parse[*verifregv14.AddVerifierParams, *verifregv14.AddVerifierParams](raw, nil, false) - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parse[*verifregv15.AddVerifierParams, *verifregv15.AddVerifierParams](raw, nil, false) } return nil, nil } -func RemoveVerifier(height int64, raw []byte) (map[string]interface{}, error) { +func RemoveVerifier(network string, height int64, raw []byte) (map[string]interface{}, error) { return parse[*address.Address, *address.Address](raw, nil, false) } -func AddVerifiedClient(height int64, raw []byte) (map[string]interface{}, error) { +func AddVerifiedClient(network string, height int64, raw []byte) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return parse[*verifregv8.AddVerifiedClientParams, *verifregv8.AddVerifiedClientParams](raw, nil, false) - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return parse[*verifregv9.AddVerifiedClientParams, *verifregv9.AddVerifiedClientParams](raw, nil, false) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parse[*verifregv10.AddVerifiedClientParams, *verifregv10.AddVerifiedClientParams](raw, nil, false) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parse[*verifregv11.AddVerifiedClientParams, *verifregv11.AddVerifiedClientParams](raw, nil, false) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parse[*verifregv12.AddVerifiedClientParams, *verifregv12.AddVerifiedClientParams](raw, nil, false) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parse[*verifregv13.AddVerifiedClientParams, *verifregv13.AddVerifiedClientParams](raw, nil, false) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parse[*verifregv14.AddVerifiedClientParams, *verifregv14.AddVerifiedClientParams](raw, nil, false) - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parse[*verifregv15.AddVerifiedClientParams, *verifregv15.AddVerifiedClientParams](raw, nil, false) } return nil, nil } -func UseBytes(height int64, raw []byte) (map[string]interface{}, error) { +func UseBytes(network string, height int64, raw []byte) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return parse[*verifregv8.UseBytesParams, *verifregv8.UseBytesParams](raw, nil, false) - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return parse[*verifregv9.UseBytesParams, *verifregv9.UseBytesParams](raw, nil, false) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parse[*verifregv10.UseBytesParams, *verifregv10.UseBytesParams](raw, nil, false) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parse[*verifregv11.UseBytesParams, *verifregv11.UseBytesParams](raw, nil, false) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parse[*verifregv12.UseBytesParams, *verifregv12.UseBytesParams](raw, nil, false) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parse[*verifregv13.UseBytesParams, *verifregv13.UseBytesParams](raw, nil, false) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parse[*verifregv14.UseBytesParams, *verifregv14.UseBytesParams](raw, nil, false) - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parse[*verifregv15.UseBytesParams, *verifregv15.UseBytesParams](raw, nil, false) } return nil, nil } -func RestoreBytes(height int64, raw []byte) (map[string]interface{}, error) { +func RestoreBytes(network string, height int64, raw []byte) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return parse[*verifregv8.RestoreBytesParams, *verifregv8.RestoreBytesParams](raw, nil, false) - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return parse[*verifregv9.RestoreBytesParams, *verifregv9.RestoreBytesParams](raw, nil, false) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parse[*verifregv10.RestoreBytesParams, *verifregv10.RestoreBytesParams](raw, nil, false) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parse[*verifregv11.RestoreBytesParams, *verifregv11.RestoreBytesParams](raw, nil, false) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parse[*verifregv12.RestoreBytesParams, *verifregv12.RestoreBytesParams](raw, nil, false) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parse[*verifregv13.RestoreBytesParams, *verifregv13.RestoreBytesParams](raw, nil, false) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parse[*verifregv14.RestoreBytesParams, *verifregv14.RestoreBytesParams](raw, nil, false) - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parse[*verifregv15.RestoreBytesParams, *verifregv15.RestoreBytesParams](raw, nil, false) } return nil, nil } -func RemoveVerifiedClientDataCap(height int64, raw []byte) (map[string]interface{}, error) { +func RemoveVerifiedClientDataCap(network string, height int64, raw []byte) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return parse[*verifregv8.DataCap, *verifregv8.DataCap](raw, nil, false) - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return parse[*verifregv9.DataCap, *verifregv9.DataCap](raw, nil, false) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parse[*verifregv10.DataCap, *verifregv10.DataCap](raw, nil, false) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parse[*verifregv11.DataCap, *verifregv11.DataCap](raw, nil, false) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parse[*verifregv12.DataCap, *verifregv12.DataCap](raw, nil, false) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parse[*verifregv13.DataCap, *verifregv13.DataCap](raw, nil, false) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parse[*verifregv14.DataCap, *verifregv14.DataCap](raw, nil, false) - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parse[*verifregv15.DataCap, *verifregv15.DataCap](raw, nil, false) } return nil, nil } -func RemoveExpiredAllocations(height int64, raw, rawReturn []byte) (map[string]interface{}, error) { +func RemoveExpiredAllocations(network string, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return nil, fmt.Errorf("not supported") - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return parse[*verifregv9.RemoveExpiredAllocationsParams, *verifregv9.RemoveExpiredAllocationsReturn](raw, rawReturn, true) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parse[*verifregv10.RemoveExpiredAllocationsParams, *verifregv10.RemoveExpiredAllocationsReturn](raw, rawReturn, true) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parse[*verifregv11.RemoveExpiredAllocationsParams, *verifregv11.RemoveExpiredAllocationsReturn](raw, rawReturn, true) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parse[*verifregv12.RemoveExpiredAllocationsParams, *verifregv12.RemoveExpiredAllocationsReturn](raw, rawReturn, true) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parse[*verifregv13.RemoveExpiredAllocationsParams, *verifregv13.RemoveExpiredAllocationsReturn](raw, rawReturn, true) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parse[*verifregv14.RemoveExpiredAllocationsParams, *verifregv14.RemoveExpiredAllocationsReturn](raw, rawReturn, true) - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parse[*verifregv15.RemoveExpiredAllocationsParams, *verifregv15.RemoveExpiredAllocationsReturn](raw, rawReturn, true) } return nil, nil } -func Deprecated1(height int64, raw []byte) (map[string]interface{}, error) { +func Deprecated1(network string, height int64, raw []byte) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return parse[*verifregv8.RestoreBytesParams, *verifregv8.RestoreBytesParams](raw, nil, false) - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return parse[*verifregv9.RestoreBytesParams, *verifregv9.RestoreBytesParams](raw, nil, false) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parse[*verifregv10.RestoreBytesParams, *verifregv10.RestoreBytesParams](raw, nil, false) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parse[*verifregv11.RestoreBytesParams, *verifregv11.RestoreBytesParams](raw, nil, false) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parse[*verifregv12.RestoreBytesParams, *verifregv12.RestoreBytesParams](raw, nil, false) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parse[*verifregv13.RestoreBytesParams, *verifregv13.RestoreBytesParams](raw, nil, false) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parse[*verifregv14.RestoreBytesParams, *verifregv14.RestoreBytesParams](raw, nil, false) - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parse[*verifregv15.RestoreBytesParams, *verifregv15.RestoreBytesParams](raw, nil, false) } return nil, nil } -func Deprecated2(height int64, raw []byte) (map[string]interface{}, error) { +func Deprecated2(network string, height int64, raw []byte) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return parse[*verifregv8.UseBytesParams, *verifregv8.UseBytesParams](raw, nil, false) - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return parse[*verifregv9.UseBytesParams, *verifregv9.UseBytesParams](raw, nil, false) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parse[*verifregv10.UseBytesParams, *verifregv10.UseBytesParams](raw, nil, false) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parse[*verifregv11.UseBytesParams, *verifregv11.UseBytesParams](raw, nil, false) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parse[*verifregv12.UseBytesParams, *verifregv12.UseBytesParams](raw, nil, false) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parse[*verifregv13.UseBytesParams, *verifregv13.UseBytesParams](raw, nil, false) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parse[*verifregv14.UseBytesParams, *verifregv14.UseBytesParams](raw, nil, false) - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parse[*verifregv15.UseBytesParams, *verifregv15.UseBytesParams](raw, nil, false) } return nil, nil } -func ClaimAllocations(height int64, raw, rawReturn []byte) (map[string]interface{}, error) { +func ClaimAllocations(network string, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return nil, fmt.Errorf("not supported") - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return parse[*verifregv9.ClaimAllocationsParams, *verifregv9.ClaimAllocationsReturn](raw, rawReturn, true) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parse[*verifregv10.ClaimAllocationsParams, *verifregv10.ClaimAllocationsReturn](raw, rawReturn, true) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parse[*verifregv11.ClaimAllocationsParams, *verifregv11.ClaimAllocationsReturn](raw, rawReturn, true) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parse[*verifregv12.ClaimAllocationsParams, *verifregv12.ClaimAllocationsReturn](raw, rawReturn, true) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parse[*verifregv13.ClaimAllocationsParams, *verifregv13.ClaimAllocationsReturn](raw, rawReturn, true) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parse[*verifregv14.ClaimAllocationsParams, *verifregv14.ClaimAllocationsReturn](raw, rawReturn, true) - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parse[*verifregv15.ClaimAllocationsParams, *verifregv15.ClaimAllocationsReturn](raw, rawReturn, true) } return nil, nil } -func GetClaims(height int64, raw, rawReturn []byte) (map[string]interface{}, error) { +func GetClaims(network string, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return nil, fmt.Errorf("not supported") - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return parse[*verifregv9.GetClaimsParams, *verifregv9.GetClaimsReturn](raw, rawReturn, true) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parse[*verifregv10.GetClaimsParams, *verifregv10.GetClaimsReturn](raw, rawReturn, true) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parse[*verifregv11.GetClaimsParams, *verifregv11.GetClaimsReturn](raw, rawReturn, true) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parse[*verifregv12.GetClaimsParams, *verifregv12.GetClaimsReturn](raw, rawReturn, true) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parse[*verifregv13.GetClaimsParams, *verifregv13.GetClaimsReturn](raw, rawReturn, true) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parse[*verifregv14.GetClaimsParams, *verifregv14.GetClaimsReturn](raw, rawReturn, true) - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parse[*verifregv15.GetClaimsParams, *verifregv15.GetClaimsReturn](raw, rawReturn, true) } return nil, nil } -func ExtendClaimTerms(height int64, raw, rawReturn []byte) (map[string]interface{}, error) { +func ExtendClaimTerms(network string, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return nil, fmt.Errorf("not supported") - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return parse[*verifregv9.ExtendClaimTermsParams, *verifregv9.ExtendClaimTermsReturn](raw, rawReturn, true) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parse[*verifregv10.ExtendClaimTermsParams, *verifregv10.ExtendClaimTermsReturn](raw, rawReturn, true) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parse[*verifregv11.ExtendClaimTermsParams, *verifregv11.ExtendClaimTermsReturn](raw, rawReturn, true) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parse[*verifregv12.ExtendClaimTermsParams, *verifregv12.ExtendClaimTermsReturn](raw, rawReturn, true) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parse[*verifregv13.ExtendClaimTermsParams, *verifregv13.ExtendClaimTermsReturn](raw, rawReturn, true) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parse[*verifregv14.ExtendClaimTermsParams, *verifregv14.ExtendClaimTermsReturn](raw, rawReturn, true) - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parse[*verifregv15.ExtendClaimTermsParams, *verifregv15.ExtendClaimTermsReturn](raw, rawReturn, true) } return nil, nil } -func RemoveExpiredClaims(height int64, raw, rawReturn []byte) (map[string]interface{}, error) { +func RemoveExpiredClaims(network string, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return nil, fmt.Errorf("not supported") - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return parse[*verifregv9.RemoveExpiredClaimsParams, *verifregv9.RemoveExpiredClaimsReturn](raw, rawReturn, true) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parse[*verifregv10.RemoveExpiredClaimsParams, *verifregv10.RemoveExpiredClaimsReturn](raw, rawReturn, true) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parse[*verifregv11.RemoveExpiredClaimsParams, *verifregv11.RemoveExpiredClaimsReturn](raw, rawReturn, true) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parse[*verifregv12.RemoveExpiredClaimsParams, *verifregv12.RemoveExpiredClaimsReturn](raw, rawReturn, true) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parse[*verifregv13.RemoveExpiredClaimsParams, *verifregv13.RemoveExpiredClaimsReturn](raw, rawReturn, true) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parse[*verifregv14.RemoveExpiredClaimsParams, *verifregv14.RemoveExpiredClaimsReturn](raw, rawReturn, true) - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parse[*verifregv15.RemoveExpiredClaimsParams, *verifregv15.RemoveExpiredClaimsReturn](raw, rawReturn, true) } return nil, nil } -func VerifregUniversalReceiverHook(height int64, raw, rawReturn []byte) (map[string]interface{}, error) { +func VerifregUniversalReceiverHook(network string, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(height): + case tools.V8.IsSupported(network, height): return nil, fmt.Errorf("not supported") - case tools.V9.IsSupported(height): + case tools.V9.IsSupported(network, height): return parse[*verifregv9.UniversalReceiverParams, *verifregv9.AllocationsResponse](raw, rawReturn, true) - case tools.V10.IsSupported(height): + case tools.V10.IsSupported(network, height): return parse[*verifregv10.UniversalReceiverParams, *verifregv10.AllocationsResponse](raw, rawReturn, true) - case tools.V11.IsSupported(height): + case tools.V11.IsSupported(network, height): return parse[*verifregv11.UniversalReceiverParams, *verifregv11.AllocationsResponse](raw, rawReturn, true) - case tools.V12.IsSupported(height): + case tools.V12.IsSupported(network, height): return parse[*verifregv12.UniversalReceiverParams, *verifregv12.AllocationsResponse](raw, rawReturn, true) - case tools.V13.IsSupported(height): + case tools.V13.IsSupported(network, height): return parse[*verifregv13.UniversalReceiverParams, *verifregv13.AllocationsResponse](raw, rawReturn, true) - case tools.V14.IsSupported(height): + case tools.V14.IsSupported(network, height): return parse[*verifregv14.UniversalReceiverParams, *verifregv14.AllocationsResponse](raw, rawReturn, true) - case tools.V15.IsSupported(height): + case tools.V15.IsSupported(network, height): return parse[*verifregv15.UniversalReceiverParams, *verifregv15.AllocationsResponse](raw, rawReturn, true) } return nil, nil diff --git a/actors/verifiedRegistry/verifiedRegistry_test.go b/actors/verifiedRegistry/verifiedRegistry_test.go index 4a4726c9..ccb4ec43 100644 --- a/actors/verifiedRegistry/verifiedRegistry_test.go +++ b/actors/verifiedRegistry/verifiedRegistry_test.go @@ -22,8 +22,8 @@ func TestMain(m *testing.M) { m.Run() } -type testFn func(height int64, raw []byte) (map[string]interface{}, error) -type testFn2 func(height int64, raw, rawReturn []byte) (map[string]interface{}, error) +type testFn func(network string, height int64, raw []byte) (map[string]interface{}, error) +type testFn2 func(network string, height int64, raw, rawReturn []byte) (map[string]interface{}, error) func TestAddVerifier(t *testing.T) { tests, err := tools.LoadTestData[map[string]any]("AddVerifier", expected) @@ -119,7 +119,7 @@ func runTest(t *testing.T, fn testFn, tests []tools.TestCase[map[string]any]) { continue } - result, err := fn(tt.Height, trace.Msg.Params) + result, err := fn(tt.Network, tt.Height, trace.Msg.Params) require.NoError(t, err) require.True(t, tools.CompareResult(result, tt.Expected)) } @@ -138,7 +138,7 @@ func runTest2(t *testing.T, fn testFn2, tests []tools.TestCase[map[string]any]) continue } - result, err := fn(tt.Height, trace.Msg.Params, trace.MsgRct.Return) + result, err := fn(tt.Network, tt.Height, trace.Msg.Params, trace.MsgRct.Return) require.NoError(t, err) require.True(t, tools.CompareResult(result, tt.Expected)) } diff --git a/tools/testutil.go b/tools/testutil.go index 44a49e3f..05d45225 100644 --- a/tools/testutil.go +++ b/tools/testutil.go @@ -162,6 +162,7 @@ type TestCase[T any] struct { Version string Url string Height int64 + Network string TipsetKey filTypes.TipSetKey Expected T Address *types.AddressInfo diff --git a/tools/version_mapping.go b/tools/version_mapping.go index c0a61660..a8a48346 100644 --- a/tools/version_mapping.go +++ b/tools/version_mapping.go @@ -2,12 +2,44 @@ package tools import "fmt" -type version int64 +var ( + LatestVersion version = version{calibration: 22000, mainnet: 22000} + V1 version = version{calibration: 0, mainnet: 0} + V2 version = version{calibration: 100, mainnet: 100} + V3 version = version{calibration: 1000, mainnet: 1000} + V4 version = version{calibration: 2000, mainnet: 2000} + V5 version = version{calibration: 3000, mainnet: 3000} + V6 version = version{calibration: 4000, mainnet: 4000} + V7 version = version{calibration: 5000, mainnet: 5000} + V8 version = version{calibration: 6000, mainnet: 6000} + V9 version = version{calibration: 7000, mainnet: 7000} + V10 version = version{calibration: 8000, mainnet: 8000} + V11 version = version{calibration: 9000, mainnet: 9000} + V12 version = version{calibration: 10000, mainnet: 10000} + V13 version = version{calibration: 11000, mainnet: 11000} + V14 version = version{calibration: 12000, mainnet: 12000} + V15 version = version{calibration: 13000, mainnet: 13000} + V16 version = version{calibration: 14000, mainnet: 14000} + V17 version = version{calibration: 15000, mainnet: 15000} + V18 version = version{calibration: 16000, mainnet: 16000} + V19 version = version{calibration: 17000, mainnet: 17000} + V20 version = version{calibration: 18000, mainnet: 18000} + V21 version = version{calibration: 19000, mainnet: 19000} + V22 version = version{calibration: 20000, mainnet: 20000} +) + +type version struct { + calibration int64 + mainnet int64 +} var supportedVersions = []version{V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22} -func (v version) IsSupported(height int64) bool { - return height <= int64(v.next()) +func (v version) IsSupported(network string, height int64) bool { + if network == "calibration" { + return height <= v.calibration + } + return height <= v.mainnet } func (v version) next() version { @@ -23,7 +55,7 @@ func (v version) next() version { } func (v version) String() string { - return fmt.Sprintf("V%d", v) + return fmt.Sprintf("V%d", v.startHeight) } func GetSupportedVersions() []version { // Create a new slice with same length and copy all elements @@ -31,29 +63,3 @@ func GetSupportedVersions() []version { copy(result, supportedVersions) return result } - -const ( - LatestVersion version = V22 - V1 version = 0 - V2 version = 100 - V3 version = 1000 - V4 version = 2000 - V5 version = 3000 - V6 version = 4000 - V7 version = 5000 - V8 version = 6000 - V9 version = 7000 - V10 version = 8000 - V11 version = 9000 - V12 version = 10000 - V13 version = 11000 - V14 version = 12000 - V15 version = 13000 - V16 version = 14000 - V17 version = 15000 - V18 version = 16000 - V19 version = 17000 - V20 version = 18000 - V21 version = 19000 - V22 version = 20000 -) From 6ed2193c0048232f46c4fde653439aeb773aa583 Mon Sep 17 00:00:00 2001 From: Eric Mokaya Date: Wed, 22 Jan 2025 18:59:03 +0300 Subject: [PATCH 12/16] feat: update correct network height and library mappings --- actors/account/account.go | 8 +- actors/cron/cron.go | 15 +- actors/datacap/allowance.go | 48 ++-- actors/datacap/burn.go | 50 ++--- actors/datacap/granularity.go | 10 +- actors/datacap/mint.go | 15 +- actors/datacap/transfer.go | 15 +- actors/eam/create.go | 44 ++-- actors/evm/evm.go | 70 +++--- actors/init/init.go | 48 ++-- actors/market/market.go | 230 ++++++++++---------- actors/miner/address.go | 128 +++++------ actors/miner/balance.go | 48 ++-- actors/miner/miner.go | 208 +++++++++--------- actors/miner/sector.go | 176 +++++++-------- actors/multisig/multisig.go | 128 +++++------ actors/multisig/values.go | 192 ++++++++-------- actors/multisig/verifier.go | 16 +- actors/paymentChannel/paymentChannel.go | 32 +-- actors/power/power.go | 160 +++++++------- actors/reward/reward.go | 32 +-- actors/verifiedRegistry/verifiedRegistry.go | 208 +++++++++--------- tools/version_mapping.go | 46 ++-- 23 files changed, 963 insertions(+), 964 deletions(-) diff --git a/actors/account/account.go b/actors/account/account.go index a769996e..4a397e9d 100644 --- a/actors/account/account.go +++ b/actors/account/account.go @@ -32,13 +32,13 @@ func AuthenticateMessage(network string, height int64, raw, rawReturn []byte) (m switch { case tools.V8.IsSupported(network, height): return nil, fmt.Errorf("not supported") - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return authenticateMessageGeneric[*accountv9.AuthenticateMessageParams, *accountv9.AuthenticateMessageParams](raw, rawReturn, &accountv9.AuthenticateMessageParams{}) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return authenticateMessageGeneric[*accountv10.AuthenticateMessageParams, *accountv10.AuthenticateMessageParams](raw, rawReturn, &accountv10.AuthenticateMessageParams{}) - case tools.V11.IsSupported(network, height): + case tools.V19.IsSupported(network, height): return authenticateMessageGeneric[*accountv11.AuthenticateMessageParams, *accountv11.AuthenticateMessageParams](raw, rawReturn, &accountv11.AuthenticateMessageParams{}) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return authenticateMessageGeneric[*accountv14.AuthenticateMessageParams, *accountv14.AuthenticateMessageParams](raw, rawReturn, &accountv14.AuthenticateMessageParams{}) default: return authenticateMessageGeneric[*accountv15.AuthenticateMessageParams, *accountv15.AuthenticateMessageParams](raw, rawReturn, &accountv15.AuthenticateMessageParams{}) diff --git a/actors/cron/cron.go b/actors/cron/cron.go index c21374a3..59d0575b 100644 --- a/actors/cron/cron.go +++ b/actors/cron/cron.go @@ -11,22 +11,21 @@ import ( "github.com/zondax/fil-parser/tools" ) -// TODO: update to correct height ranges func CronConstructor(network string, height int64, raw []byte) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): return cronConstructorGeneric[*cronv8.ConstructorParams](raw, &cronv8.ConstructorParams{}) - case tools.V7.IsSupported(network, height): + case tools.V15.IsSupported(network, height): return cronConstructorGeneric[*cronv7.ConstructorParams](raw, &cronv7.ConstructorParams{}) - case tools.V6.IsSupported(network, height): + case tools.V14.IsSupported(network, height): return cronConstructorGeneric[*cronv6.ConstructorParams](raw, &cronv6.ConstructorParams{}) - case tools.V5.IsSupported(network, height): + case tools.V13.IsSupported(network, height): return cronConstructorGeneric[*cronv5.ConstructorParams](raw, &cronv5.ConstructorParams{}) - case tools.V4.IsSupported(network, height): + case tools.V12.IsSupported(network, height): return cronConstructorGeneric[*cronv4.ConstructorParams](raw, &cronv4.ConstructorParams{}) - case tools.V3.IsSupported(network, height): + case tools.V10.IsSupported(network, height) || tools.V11.IsSupported(network, height): return cronConstructorGeneric[*cronv3.ConstructorParams](raw, &cronv3.ConstructorParams{}) - case tools.V2.IsSupported(network, height): + case tools.V9.IsSupported(network, height): return cronConstructorGeneric[*cronv2.ConstructorParams](raw, &cronv2.ConstructorParams{}) } return nil, nil diff --git a/actors/datacap/allowance.go b/actors/datacap/allowance.go index 20cb97a3..68b54032 100644 --- a/actors/datacap/allowance.go +++ b/actors/datacap/allowance.go @@ -16,15 +16,17 @@ func IncreaseAllowance(network string, height int64, raw, rawReturn []byte) (map switch { case tools.V8.IsSupported(network, height): return nil, fmt.Errorf("not supported") - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return parse[*datacapv9.IncreaseAllowanceParams, *abi.TokenAmount](raw, rawReturn, true) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parse[*datacapv10.IncreaseAllowanceParams, *abi.TokenAmount](raw, rawReturn, true) - case tools.V11.IsSupported(network, height): + case tools.V19.IsSupported(network, height) || tools.V20.IsSupported(network, height): return parse[*datacapv11.IncreaseAllowanceParams, *abi.TokenAmount](raw, rawReturn, true) - case tools.V14.IsSupported(network, height): + case tools.V21.IsSupported(network, height): + return parse[*datacapv11.IncreaseAllowanceParams, *abi.TokenAmount](raw, rawReturn, true) + case tools.V23.IsSupported(network, height): return parse[*datacapv14.IncreaseAllowanceParams, *abi.TokenAmount](raw, rawReturn, true) - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parse[*datacapv15.IncreaseAllowanceParams, *abi.TokenAmount](raw, rawReturn, true) } return nil, fmt.Errorf("not supported") @@ -34,15 +36,17 @@ func DecreaseAllowance(network string, height int64, raw, rawReturn []byte) (map switch { case tools.V8.IsSupported(network, height): return nil, fmt.Errorf("not supported") - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return parse[*datacapv9.DecreaseAllowanceParams, *abi.TokenAmount](raw, rawReturn, true) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parse[*datacapv10.DecreaseAllowanceParams, *abi.TokenAmount](raw, rawReturn, true) - case tools.V11.IsSupported(network, height): + case tools.V19.IsSupported(network, height) || tools.V20.IsSupported(network, height): + return parse[*datacapv11.DecreaseAllowanceParams, *abi.TokenAmount](raw, rawReturn, true) + case tools.V21.IsSupported(network, height): return parse[*datacapv11.DecreaseAllowanceParams, *abi.TokenAmount](raw, rawReturn, true) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parse[*datacapv14.DecreaseAllowanceParams, *abi.TokenAmount](raw, rawReturn, true) - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parse[*datacapv15.DecreaseAllowanceParams, *abi.TokenAmount](raw, rawReturn, true) } return nil, fmt.Errorf("not supported") @@ -52,15 +56,17 @@ func RevokeAllowance(network string, height int64, raw, rawReturn []byte) (map[s switch { case tools.V8.IsSupported(network, height): return nil, fmt.Errorf("not supported") - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return parse[*datacapv9.RevokeAllowanceParams, *abi.TokenAmount](raw, rawReturn, true) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parse[*datacapv10.RevokeAllowanceParams, *abi.TokenAmount](raw, rawReturn, true) - case tools.V11.IsSupported(network, height): + case tools.V19.IsSupported(network, height) || tools.V20.IsSupported(network, height): return parse[*datacapv11.RevokeAllowanceParams, *abi.TokenAmount](raw, rawReturn, true) - case tools.V14.IsSupported(network, height): + case tools.V21.IsSupported(network, height): + return parse[*datacapv11.RevokeAllowanceParams, *abi.TokenAmount](raw, rawReturn, true) + case tools.V23.IsSupported(network, height): return parse[*datacapv14.RevokeAllowanceParams, *abi.TokenAmount](raw, rawReturn, true) - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parse[*datacapv15.RevokeAllowanceParams, *abi.TokenAmount](raw, rawReturn, true) } return nil, fmt.Errorf("not supported") @@ -70,15 +76,17 @@ func GetAllowance(network string, height int64, raw, rawReturn []byte) (map[stri switch { case tools.V8.IsSupported(network, height): return nil, fmt.Errorf("not supported") - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return parse[*datacapv9.GetAllowanceParams, *abi.TokenAmount](raw, rawReturn, true) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parse[*datacapv10.GetAllowanceParams, *abi.TokenAmount](raw, rawReturn, true) - case tools.V11.IsSupported(network, height): + case tools.V19.IsSupported(network, height) || tools.V20.IsSupported(network, height): + return parse[*datacapv11.GetAllowanceParams, *abi.TokenAmount](raw, rawReturn, true) + case tools.V21.IsSupported(network, height): return parse[*datacapv11.GetAllowanceParams, *abi.TokenAmount](raw, rawReturn, true) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parse[*datacapv14.GetAllowanceParams, *abi.TokenAmount](raw, rawReturn, true) - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parse[*datacapv15.GetAllowanceParams, *abi.TokenAmount](raw, rawReturn, true) } return nil, fmt.Errorf("not supported") diff --git a/actors/datacap/burn.go b/actors/datacap/burn.go index f39708fa..868f6c5c 100644 --- a/actors/datacap/burn.go +++ b/actors/datacap/burn.go @@ -5,8 +5,6 @@ import ( datacapv10 "github.com/filecoin-project/go-state-types/builtin/v10/datacap" datacapv11 "github.com/filecoin-project/go-state-types/builtin/v11/datacap" - datacapv12 "github.com/filecoin-project/go-state-types/builtin/v12/datacap" - datacapv13 "github.com/filecoin-project/go-state-types/builtin/v13/datacap" datacapv14 "github.com/filecoin-project/go-state-types/builtin/v14/datacap" datacapv15 "github.com/filecoin-project/go-state-types/builtin/v15/datacap" datacapv9 "github.com/filecoin-project/go-state-types/builtin/v9/datacap" @@ -17,19 +15,17 @@ func BurnExported(network string, height int64, raw, rawReturn []byte) (map[stri switch { case tools.V8.IsSupported(network, height): return nil, fmt.Errorf("not supported") - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return parse[*datacapv9.BurnParams, *datacapv9.BurnReturn](raw, rawReturn, true) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parse[*datacapv10.BurnParams, *datacapv10.BurnReturn](raw, rawReturn, true) - case tools.V11.IsSupported(network, height): + case tools.V19.IsSupported(network, height) || tools.V20.IsSupported(network, height): return parse[*datacapv11.BurnParams, *datacapv11.BurnReturn](raw, rawReturn, true) - case tools.V12.IsSupported(network, height): - return parse[*datacapv12.BurnParams, *datacapv12.BurnReturn](raw, rawReturn, true) - case tools.V13.IsSupported(network, height): - return parse[*datacapv13.BurnParams, *datacapv13.BurnReturn](raw, rawReturn, true) - case tools.V14.IsSupported(network, height): + case tools.V21.IsSupported(network, height): + return parse[*datacapv11.BurnParams, *datacapv11.BurnReturn](raw, rawReturn, true) + case tools.V23.IsSupported(network, height): return parse[*datacapv14.BurnParams, *datacapv14.BurnReturn](raw, rawReturn, true) - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parse[*datacapv15.BurnParams, *datacapv15.BurnReturn](raw, rawReturn, true) } return nil, fmt.Errorf("not supported") @@ -39,19 +35,17 @@ func BurnFromExported(network string, height int64, raw, rawReturn []byte) (map[ switch { case tools.V8.IsSupported(network, height): return nil, fmt.Errorf("not supported") - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return parse[*datacapv9.BurnFromParams, *datacapv9.BurnFromReturn](raw, rawReturn, true) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parse[*datacapv10.BurnFromParams, *datacapv10.BurnFromReturn](raw, rawReturn, true) - case tools.V11.IsSupported(network, height): + case tools.V19.IsSupported(network, height) || tools.V20.IsSupported(network, height): + return parse[*datacapv11.BurnFromParams, *datacapv11.BurnFromReturn](raw, rawReturn, true) + case tools.V21.IsSupported(network, height): return parse[*datacapv11.BurnFromParams, *datacapv11.BurnFromReturn](raw, rawReturn, true) - case tools.V12.IsSupported(network, height): - return parse[*datacapv12.BurnFromParams, *datacapv12.BurnFromReturn](raw, rawReturn, true) - case tools.V13.IsSupported(network, height): - return parse[*datacapv13.BurnFromParams, *datacapv13.BurnFromReturn](raw, rawReturn, true) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parse[*datacapv14.BurnFromParams, *datacapv14.BurnFromReturn](raw, rawReturn, true) - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parse[*datacapv15.BurnFromParams, *datacapv15.BurnFromReturn](raw, rawReturn, true) } return nil, fmt.Errorf("not supported") @@ -61,19 +55,17 @@ func DestroyExported(network string, height int64, raw, rawReturn []byte) (map[s switch { case tools.V8.IsSupported(network, height): return nil, fmt.Errorf("not supported") - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return parse[*datacapv9.DestroyParams, *datacapv9.BurnReturn](raw, rawReturn, true) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parse[*datacapv10.DestroyParams, *datacapv10.BurnReturn](raw, rawReturn, true) - case tools.V11.IsSupported(network, height): + case tools.V19.IsSupported(network, height) || tools.V20.IsSupported(network, height): + return parse[*datacapv11.DestroyParams, *datacapv11.BurnReturn](raw, rawReturn, true) + case tools.V21.IsSupported(network, height): return parse[*datacapv11.DestroyParams, *datacapv11.BurnReturn](raw, rawReturn, true) - case tools.V12.IsSupported(network, height): - return parse[*datacapv12.DestroyParams, *datacapv12.BurnReturn](raw, rawReturn, true) - case tools.V13.IsSupported(network, height): - return parse[*datacapv13.DestroyParams, *datacapv13.BurnReturn](raw, rawReturn, true) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parse[*datacapv14.DestroyParams, *datacapv14.BurnReturn](raw, rawReturn, true) - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parse[*datacapv15.DestroyParams, *datacapv15.BurnReturn](raw, rawReturn, true) } return nil, fmt.Errorf("not supported") diff --git a/actors/datacap/granularity.go b/actors/datacap/granularity.go index 9d17b754..d15feca9 100644 --- a/actors/datacap/granularity.go +++ b/actors/datacap/granularity.go @@ -16,35 +16,35 @@ func GranularityExported(network string, height int64, rawReturn []byte) (map[st switch { case tools.V8.IsSupported(network, height): return nil, fmt.Errorf("not supported") - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): data, err := parse[*datacapv10.GranularityReturn, *datacapv10.GranularityReturn](rawReturn, nil, false) if err != nil { return nil, err } data[parser.ReturnKey] = data[parser.ParamsKey] return data, nil - case tools.V11.IsSupported(network, height): + case tools.V19.IsSupported(network, height) || tools.V20.IsSupported(network, height): data, err := parse[*datacapv11.GranularityReturn, *datacapv11.GranularityReturn](rawReturn, nil, false) if err != nil { return nil, err } data[parser.ReturnKey] = data[parser.ParamsKey] return data, nil - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): data, err := parse[*datacapv12.GranularityReturn, *datacapv12.GranularityReturn](rawReturn, nil, false) if err != nil { return nil, err } data[parser.ReturnKey] = data[parser.ParamsKey] return data, nil - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): data, err := parse[*datacapv14.GranularityReturn, *datacapv14.GranularityReturn](rawReturn, nil, false) if err != nil { return nil, err } data[parser.ReturnKey] = data[parser.ParamsKey] return data, nil - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): data, err := parse[*datacapv15.GranularityReturn, *datacapv15.GranularityReturn](rawReturn, nil, false) if err != nil { return nil, err diff --git a/actors/datacap/mint.go b/actors/datacap/mint.go index 60b2c658..781bb024 100644 --- a/actors/datacap/mint.go +++ b/actors/datacap/mint.go @@ -6,7 +6,6 @@ import ( datacapv10 "github.com/filecoin-project/go-state-types/builtin/v10/datacap" datacapv11 "github.com/filecoin-project/go-state-types/builtin/v11/datacap" datacapv12 "github.com/filecoin-project/go-state-types/builtin/v12/datacap" - datacapv13 "github.com/filecoin-project/go-state-types/builtin/v13/datacap" datacapv14 "github.com/filecoin-project/go-state-types/builtin/v14/datacap" datacapv15 "github.com/filecoin-project/go-state-types/builtin/v15/datacap" datacapv9 "github.com/filecoin-project/go-state-types/builtin/v9/datacap" @@ -22,19 +21,19 @@ func MintExported(network string, height int64, raw, rawReturn []byte) (map[stri switch { case tools.V8.IsSupported(network, height): return nil, fmt.Errorf("not supported") - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return parse[*datacapv9.MintParams, *datacapv9.MintReturn](raw, rawReturn, true) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parse[*datacapv10.MintParams, *datacapv10.MintReturn](raw, rawReturn, true) - case tools.V11.IsSupported(network, height): + case tools.V19.IsSupported(network, height) || tools.V20.IsSupported(network, height): return parse[*datacapv11.MintParams, *datacapv11.MintReturn](raw, rawReturn, true) case tools.V12.IsSupported(network, height): return parse[*datacapv12.MintParams, *datacapv12.MintReturn](raw, rawReturn, true) - case tools.V13.IsSupported(network, height): - return parse[*datacapv13.MintParams, *datacapv13.MintReturn](raw, rawReturn, true) - case tools.V14.IsSupported(network, height): + case tools.V21.IsSupported(network, height): + return parse[*datacapv12.MintParams, *datacapv12.MintReturn](raw, rawReturn, true) + case tools.V23.IsSupported(network, height): return parse[*datacapv14.MintParams, *datacapv14.MintReturn](raw, rawReturn, true) - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parse[*datacapv15.MintParams, *datacapv15.MintReturn](raw, rawReturn, true) } return nil, fmt.Errorf("not supported") diff --git a/actors/datacap/transfer.go b/actors/datacap/transfer.go index 7a808bc3..13afdd06 100644 --- a/actors/datacap/transfer.go +++ b/actors/datacap/transfer.go @@ -6,7 +6,6 @@ import ( datacapv10 "github.com/filecoin-project/go-state-types/builtin/v10/datacap" datacapv11 "github.com/filecoin-project/go-state-types/builtin/v11/datacap" datacapv12 "github.com/filecoin-project/go-state-types/builtin/v12/datacap" - datacapv13 "github.com/filecoin-project/go-state-types/builtin/v13/datacap" datacapv14 "github.com/filecoin-project/go-state-types/builtin/v14/datacap" datacapv15 "github.com/filecoin-project/go-state-types/builtin/v15/datacap" datacapv9 "github.com/filecoin-project/go-state-types/builtin/v9/datacap" @@ -17,19 +16,19 @@ func TransferExported(network string, height int64, raw, rawReturn []byte) (map[ switch { case tools.V8.IsSupported(network, height): return nil, fmt.Errorf("not supported") - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return parse[*datacapv9.TransferParams, *datacapv9.TransferReturn](raw, rawReturn, true) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parse[*datacapv10.TransferParams, *datacapv10.TransferReturn](raw, rawReturn, true) - case tools.V11.IsSupported(network, height): + case tools.V19.IsSupported(network, height) || tools.V20.IsSupported(network, height): return parse[*datacapv11.TransferParams, *datacapv11.TransferReturn](raw, rawReturn, true) case tools.V12.IsSupported(network, height): return parse[*datacapv12.TransferParams, *datacapv12.TransferReturn](raw, rawReturn, true) - case tools.V13.IsSupported(network, height): - return parse[*datacapv13.TransferParams, *datacapv13.TransferReturn](raw, rawReturn, true) - case tools.V14.IsSupported(network, height): + case tools.V21.IsSupported(network, height): + return parse[*datacapv12.TransferParams, *datacapv12.TransferReturn](raw, rawReturn, true) + case tools.V23.IsSupported(network, height): return parse[*datacapv14.TransferParams, *datacapv14.TransferReturn](raw, rawReturn, true) - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parse[*datacapv15.TransferParams, *datacapv15.TransferReturn](raw, rawReturn, true) } return nil, fmt.Errorf("not supported") diff --git a/actors/eam/create.go b/actors/eam/create.go index d8cd63f2..88020b9d 100644 --- a/actors/eam/create.go +++ b/actors/eam/create.go @@ -18,19 +18,19 @@ import ( func ParseCreateExternal(network string, height int64, rawParams, rawReturn []byte, msgCid cid.Cid) (map[string]interface{}, *types.AddressInfo, error) { external := true switch { - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parseCreate[*eamv15.CreateExternalReturn](rawParams, rawReturn, msgCid, external) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parseCreate[*eamv14.CreateExternalReturn](rawParams, rawReturn, msgCid, external) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parseCreate[*eamv13.CreateExternalReturn](rawParams, rawReturn, msgCid, external) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parseCreate[*eamv12.CreateExternalReturn](rawParams, rawReturn, msgCid, external) - case tools.V11.IsSupported(network, height): - return parseCreate[*eamv11.CreateExternalReturn](rawParams, rawReturn, msgCid, external) - case tools.V10.IsSupported(network, height): + case tools.V19.IsSupported(network, height) || tools.V20.IsSupported(network, height): + return parseCreate[*eamv13.CreateExternalReturn](rawParams, rawReturn, msgCid, external) + case tools.V18.IsSupported(network, height): return parseCreate[*eamv10.CreateExternalReturn](rawParams, rawReturn, msgCid, external) - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return nil, nil, fmt.Errorf("unsupported height: %d", height) } return nil, nil, fmt.Errorf("unsupported height: %d", height) @@ -39,19 +39,19 @@ func ParseCreateExternal(network string, height int64, rawParams, rawReturn []by func ParseCreate(network string, height int64, rawParams, rawReturn []byte, msgCid cid.Cid) (map[string]interface{}, *types.AddressInfo, error) { external := false switch { - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parseCreate[*eamv15.CreateReturn](rawParams, rawReturn, msgCid, external) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parseCreate[*eamv14.CreateReturn](rawParams, rawReturn, msgCid, external) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parseCreate[*eamv13.CreateReturn](rawParams, rawReturn, msgCid, external) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parseCreate[*eamv12.CreateReturn](rawParams, rawReturn, msgCid, external) - case tools.V11.IsSupported(network, height): + case tools.V19.IsSupported(network, height) || tools.V20.IsSupported(network, height): return parseCreate[*eamv11.CreateReturn](rawParams, rawReturn, msgCid, external) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parseCreate[*eamv10.CreateReturn](rawParams, rawReturn, msgCid, external) - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return nil, nil, fmt.Errorf("unsupported height: %d", height) } return nil, nil, fmt.Errorf("unsupported height: %d", height) @@ -60,19 +60,19 @@ func ParseCreate(network string, height int64, rawParams, rawReturn []byte, msgC func ParseCreate2(network string, height int64, rawParams, rawReturn []byte, msgCid cid.Cid) (map[string]interface{}, *types.AddressInfo, error) { external := false switch { - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parseCreate[*eamv15.Create2Return](rawParams, rawReturn, msgCid, external) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parseCreate[*eamv14.Create2Return](rawParams, rawReturn, msgCid, external) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parseCreate[*eamv13.Create2Return](rawParams, rawReturn, msgCid, external) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parseCreate[*eamv12.Create2Return](rawParams, rawReturn, msgCid, external) - case tools.V11.IsSupported(network, height): + case tools.V19.IsSupported(network, height) || tools.V20.IsSupported(network, height): return parseCreate[*eamv11.Create2Return](rawParams, rawReturn, msgCid, external) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parseCreate[*eamv10.Create2Return](rawParams, rawReturn, msgCid, external) - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return nil, nil, fmt.Errorf("unsupported height: %d", height) } return nil, nil, fmt.Errorf("unsupported height: %d", height) diff --git a/actors/evm/evm.go b/actors/evm/evm.go index 2c5e6e8b..eb2f95d7 100644 --- a/actors/evm/evm.go +++ b/actors/evm/evm.go @@ -46,17 +46,17 @@ func InvokeContract(network string, height int64, rawParams, rawReturn []byte) ( func Resurrect(network string, height int64, raw []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parse[*evmv15.ResurrectParams, *evmv15.ResurrectParams](raw, nil, false) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parse[*evmv14.ResurrectParams, *evmv14.ResurrectParams](raw, nil, false) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parse[*evmv13.ResurrectParams, *evmv13.ResurrectParams](raw, nil, false) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parse[*evmv12.ResurrectParams, *evmv12.ResurrectParams](raw, nil, false) - case tools.V11.IsSupported(network, height): + case tools.V20.IsSupported(network, height): return parse[*evmv11.ResurrectParams, *evmv11.ResurrectParams](raw, nil, false) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parse[*evmv10.ResurrectParams, *evmv10.ResurrectParams](raw, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) @@ -64,17 +64,17 @@ func Resurrect(network string, height int64, raw []byte) (map[string]interface{} func InvokeContractDelegate(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parse[*evmv15.DelegateCallParams, *abi.CborBytes](rawParams, rawReturn, true) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parse[*evmv14.DelegateCallParams, *abi.CborBytes](rawParams, rawReturn, true) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parse[*evmv13.DelegateCallParams, *abi.CborBytes](rawParams, rawReturn, true) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parse[*evmv12.DelegateCallParams, *abi.CborBytes](rawParams, rawReturn, true) - case tools.V11.IsSupported(network, height): + case tools.V20.IsSupported(network, height): return parse[*evmv11.DelegateCallParams, *abi.CborBytes](rawParams, rawReturn, true) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parse[*evmv10.DelegateCallParams, *abi.CborBytes](rawParams, rawReturn, true) } return nil, fmt.Errorf("unsupported height: %d", height) @@ -82,7 +82,7 @@ func InvokeContractDelegate(network string, height int64, rawParams, rawReturn [ func GetByteCode(network string, height int64, raw []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): data, err := parse[*evmv15.GetBytecodeReturn, *evmv15.GetBytecodeReturn](raw, nil, false) if err != nil { return nil, err @@ -90,7 +90,7 @@ func GetByteCode(network string, height int64, raw []byte) (map[string]interface // The return value is the same as the params data[parser.ReturnKey] = data[parser.ParamsKey] return data, nil - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): data, err := parse[*evmv14.GetBytecodeReturn, *evmv14.GetBytecodeReturn](raw, nil, false) if err != nil { return nil, err @@ -98,7 +98,7 @@ func GetByteCode(network string, height int64, raw []byte) (map[string]interface // The return value is the same as the params data[parser.ReturnKey] = data[parser.ParamsKey] return data, nil - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): data, err := parse[*evmv13.GetBytecodeReturn, *evmv13.GetBytecodeReturn](raw, nil, false) if err != nil { return nil, err @@ -106,7 +106,7 @@ func GetByteCode(network string, height int64, raw []byte) (map[string]interface // The return value is the same as the params data[parser.ReturnKey] = data[parser.ParamsKey] return data, nil - case tools.V11.IsSupported(network, height): + case tools.V20.IsSupported(network, height): data, err := parse[*evmv11.GetBytecodeReturn, *evmv11.GetBytecodeReturn](raw, nil, false) if err != nil { return nil, err @@ -114,7 +114,7 @@ func GetByteCode(network string, height int64, raw []byte) (map[string]interface // The return value is the same as the params data[parser.ReturnKey] = data[parser.ParamsKey] return data, nil - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): data, err := parse[*evmv10.GetBytecodeReturn, *evmv10.GetBytecodeReturn](raw, nil, false) if err != nil { return nil, err @@ -128,7 +128,7 @@ func GetByteCode(network string, height int64, raw []byte) (map[string]interface func GetByteCodeHash(network string, height int64, raw []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): data, err := parse[*abi.CborBytes, *abi.CborBytes](raw, nil, false) if err != nil { return nil, err @@ -136,7 +136,7 @@ func GetByteCodeHash(network string, height int64, raw []byte) (map[string]inter // The return value is the same as the params data[parser.ReturnKey] = data[parser.ParamsKey] return data, nil - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): data, err := parse[*abi.CborBytes, *abi.CborBytes](raw, nil, false) if err != nil { return nil, err @@ -144,7 +144,7 @@ func GetByteCodeHash(network string, height int64, raw []byte) (map[string]inter // The return value is the same as the params data[parser.ReturnKey] = data[parser.ParamsKey] return data, nil - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): data, err := parse[*abi.CborBytes, *abi.CborBytes](raw, nil, false) if err != nil { return nil, err @@ -152,7 +152,7 @@ func GetByteCodeHash(network string, height int64, raw []byte) (map[string]inter // The return value is the same as the params data[parser.ReturnKey] = data[parser.ParamsKey] return data, nil - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): data, err := parse[*abi.CborBytes, *abi.CborBytes](raw, nil, false) if err != nil { return nil, err @@ -160,7 +160,7 @@ func GetByteCodeHash(network string, height int64, raw []byte) (map[string]inter // The return value is the same as the params data[parser.ReturnKey] = data[parser.ParamsKey] return data, nil - case tools.V11.IsSupported(network, height): + case tools.V20.IsSupported(network, height): data, err := parse[*abi.CborBytes, *abi.CborBytes](raw, nil, false) if err != nil { return nil, err @@ -168,7 +168,7 @@ func GetByteCodeHash(network string, height int64, raw []byte) (map[string]inter // The return value is the same as the params data[parser.ReturnKey] = data[parser.ParamsKey] return data, nil - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): data, err := parse[*abi.CborBytes, *abi.CborBytes](raw, nil, false) if err != nil { return nil, err @@ -182,17 +182,17 @@ func GetByteCodeHash(network string, height int64, raw []byte) (map[string]inter func EVMConstructor(network string, height int64, raw []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parse[*evmv15.ConstructorParams, *evmv15.ConstructorParams](raw, nil, false) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parse[*evmv14.ConstructorParams, *evmv14.ConstructorParams](raw, nil, false) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parse[*evmv13.ConstructorParams, *evmv13.ConstructorParams](raw, nil, false) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parse[*evmv12.ConstructorParams, *evmv12.ConstructorParams](raw, nil, false) - case tools.V11.IsSupported(network, height): + case tools.V20.IsSupported(network, height): return parse[*evmv11.ConstructorParams, *evmv11.ConstructorParams](raw, nil, false) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parse[*evmv10.ConstructorParams, *evmv10.ConstructorParams](raw, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) @@ -200,17 +200,17 @@ func EVMConstructor(network string, height int64, raw []byte) (map[string]interf func GetStorageAt(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parse[*evmv15.GetStorageAtParams, *abi.CborBytes](rawParams, rawReturn, true) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parse[*evmv14.GetStorageAtParams, *abi.CborBytes](rawParams, rawReturn, true) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parse[*evmv13.GetStorageAtParams, *abi.CborBytes](rawParams, rawReturn, true) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parse[*evmv12.GetStorageAtParams, *abi.CborBytes](rawParams, rawReturn, true) - case tools.V11.IsSupported(network, height): + case tools.V20.IsSupported(network, height): return parse[*evmv11.GetStorageAtParams, *abi.CborBytes](rawParams, rawReturn, true) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parse[*evmv10.GetStorageAtParams, *abi.CborBytes](rawParams, rawReturn, true) } return nil, fmt.Errorf("unsupported height: %d", height) diff --git a/actors/init/init.go b/actors/init/init.go index ce941b7e..44a3c537 100644 --- a/actors/init/init.go +++ b/actors/init/init.go @@ -19,21 +19,21 @@ import ( func InitConstructor(network string, height int64, raw []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return initConstructor[*builtinInitv15.ConstructorParams](raw) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return initConstructor[*builtinInitv14.ConstructorParams](raw) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return initConstructor[*builtinInitv13.ConstructorParams](raw) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return initConstructor[*builtinInitv12.ConstructorParams](raw) - case tools.V11.IsSupported(network, height): + case tools.V20.IsSupported(network, height): return initConstructor[*builtinInitv11.ConstructorParams](raw) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return initConstructor[*builtinInitv10.ConstructorParams](raw) - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return initConstructor[*builtinInitv9.ConstructorParams](raw) - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): return initConstructor[*builtinInitv8.ConstructorParams](raw) } return nil, fmt.Errorf("unsupported height: %d", height) @@ -41,21 +41,21 @@ func InitConstructor(network string, height int64, raw []byte) (map[string]inter func ParseExec(network string, height int64, msg *parser.LotusMessage, raw []byte) (map[string]interface{}, *types.AddressInfo, error) { switch { - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parseExec[*builtinInitv15.ExecParams, *builtinInitv15.ExecReturn](msg, raw) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parseExec[*builtinInitv14.ExecParams, *builtinInitv14.ExecReturn](msg, raw) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parseExec[*builtinInitv13.ExecParams, *builtinInitv13.ExecReturn](msg, raw) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parseExec[*builtinInitv12.ExecParams, *builtinInitv12.ExecReturn](msg, raw) - case tools.V11.IsSupported(network, height): + case tools.V20.IsSupported(network, height): return parseExec[*builtinInitv11.ExecParams, *builtinInitv11.ExecReturn](msg, raw) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parseExec[*builtinInitv10.ExecParams, *builtinInitv10.ExecReturn](msg, raw) - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return parseExec[*builtinInitv9.ExecParams, *builtinInitv9.ExecReturn](msg, raw) - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): return parseExec[*builtinInitv8.ExecParams, *builtinInitv8.ExecReturn](msg, raw) } return nil, nil, fmt.Errorf("unsupported height: %d", height) @@ -63,21 +63,21 @@ func ParseExec(network string, height int64, msg *parser.LotusMessage, raw []byt func ParseExec4(network string, height int64, msg *parser.LotusMessage, raw []byte) (map[string]interface{}, *types.AddressInfo, error) { switch { - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parseExec[*builtinInitv15.Exec4Params, *builtinInitv15.Exec4Return](msg, raw) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parseExec[*builtinInitv14.Exec4Params, *builtinInitv14.Exec4Return](msg, raw) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parseExec[*builtinInitv13.Exec4Params, *builtinInitv13.Exec4Return](msg, raw) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parseExec[*builtinInitv12.Exec4Params, *builtinInitv12.Exec4Return](msg, raw) - case tools.V11.IsSupported(network, height): + case tools.V20.IsSupported(network, height): return parseExec[*builtinInitv11.Exec4Params, *builtinInitv11.Exec4Return](msg, raw) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parseExec[*builtinInitv10.Exec4Params, *builtinInitv10.Exec4Return](msg, raw) - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return nil, nil, fmt.Errorf("unsupported height: %d", height) - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): return nil, nil, fmt.Errorf("unsupported height: %d", height) } return nil, nil, fmt.Errorf("unsupported height: %d", height) diff --git a/actors/market/market.go b/actors/market/market.go index 5793ee2b..4899d03f 100644 --- a/actors/market/market.go +++ b/actors/market/market.go @@ -17,17 +17,17 @@ import ( func ParseAddBalance(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parseGeneric[*address.Address, *address.Address](rawParams, nil, false) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parseGeneric[*address.Address, *address.Address](rawParams, nil, false) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parseGeneric[*address.Address, *address.Address](rawParams, nil, false) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parseGeneric[*address.Address, *address.Address](rawParams, nil, false) - case tools.V11.IsSupported(network, height): + case tools.V19.IsSupported(network, height): return parseGeneric[*address.Address, *address.Address](rawParams, nil, false) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parseGeneric[*address.Address, *address.Address](rawParams, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) @@ -35,21 +35,21 @@ func ParseAddBalance(network string, height int64, rawParams []byte) (map[string func ParseWithdrawBalance(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parseGeneric[*v15Market.WithdrawBalanceParams, *v15Market.WithdrawBalanceParams](rawParams, nil, false) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parseGeneric[*v14Market.WithdrawBalanceParams, *v14Market.WithdrawBalanceParams](rawParams, nil, false) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parseGeneric[*v13Market.WithdrawBalanceParams, *v13Market.WithdrawBalanceParams](rawParams, nil, false) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parseGeneric[*v12Market.WithdrawBalanceParams, *v12Market.WithdrawBalanceParams](rawParams, nil, false) - case tools.V11.IsSupported(network, height): + case tools.V19.IsSupported(network, height): return parseGeneric[*v11Market.WithdrawBalanceParams, *v11Market.WithdrawBalanceParams](rawParams, nil, false) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parseGeneric[*v10Market.WithdrawBalanceParams, *v10Market.WithdrawBalanceParams](rawParams, nil, false) - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return parseGeneric[*v9Market.WithdrawBalanceParams, *v9Market.WithdrawBalanceParams](rawParams, nil, false) - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): return parseGeneric[*v8Market.WithdrawBalanceParams, *v8Market.WithdrawBalanceParams](rawParams, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) @@ -57,21 +57,21 @@ func ParseWithdrawBalance(network string, height int64, rawParams []byte) (map[s func PublishStorageDealsParams(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parseGeneric[*v15Market.PublishStorageDealsParams, *v15Market.PublishStorageDealsReturn](rawParams, rawReturn, true) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parseGeneric[*v14Market.PublishStorageDealsParams, *v14Market.PublishStorageDealsReturn](rawParams, rawReturn, true) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parseGeneric[*v13Market.PublishStorageDealsParams, *v13Market.PublishStorageDealsReturn](rawParams, rawReturn, true) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parseGeneric[*v12Market.PublishStorageDealsParams, *v12Market.PublishStorageDealsReturn](rawParams, rawReturn, true) - case tools.V11.IsSupported(network, height): + case tools.V19.IsSupported(network, height): return parseGeneric[*v11Market.PublishStorageDealsParams, *v11Market.PublishStorageDealsReturn](rawParams, rawReturn, true) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parseGeneric[*v10Market.PublishStorageDealsParams, *v10Market.PublishStorageDealsReturn](rawParams, rawReturn, true) - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return parseGeneric[*v9Market.PublishStorageDealsParams, *v9Market.PublishStorageDealsReturn](rawParams, rawReturn, true) - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): return parseGeneric[*v8Market.PublishStorageDealsParams, *v8Market.PublishStorageDealsReturn](rawParams, rawReturn, true) } return nil, fmt.Errorf("unsupported height: %d", height) @@ -79,21 +79,21 @@ func PublishStorageDealsParams(network string, height int64, rawParams, rawRetur func VerifyDealsForActivationParams(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parseGeneric[*v15Market.VerifyDealsForActivationParams, *v15Market.VerifyDealsForActivationReturn](rawParams, rawReturn, true) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parseGeneric[*v14Market.VerifyDealsForActivationParams, *v14Market.VerifyDealsForActivationReturn](rawParams, rawReturn, true) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parseGeneric[*v13Market.VerifyDealsForActivationParams, *v13Market.VerifyDealsForActivationReturn](rawParams, rawReturn, true) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parseGeneric[*v12Market.VerifyDealsForActivationParams, *v12Market.VerifyDealsForActivationReturn](rawParams, rawReturn, true) - case tools.V11.IsSupported(network, height): + case tools.V19.IsSupported(network, height): return parseGeneric[*v11Market.VerifyDealsForActivationParams, *v11Market.VerifyDealsForActivationReturn](rawParams, rawReturn, true) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parseGeneric[*v10Market.VerifyDealsForActivationParams, *v10Market.VerifyDealsForActivationReturn](rawParams, rawReturn, true) - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return parseGeneric[*v9Market.VerifyDealsForActivationParams, *v9Market.VerifyDealsForActivationReturn](rawParams, rawReturn, true) - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): return parseGeneric[*v8Market.VerifyDealsForActivationParams, *v8Market.VerifyDealsForActivationReturn](rawParams, rawReturn, true) } return nil, fmt.Errorf("unsupported height: %d", height) @@ -101,19 +101,19 @@ func VerifyDealsForActivationParams(network string, height int64, rawParams, raw func ActivateDealsParams(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parseGeneric[*v15Market.ActivateDealsParams, *v15Market.ActivateDealsResult](rawParams, rawReturn, true) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parseGeneric[*v14Market.ActivateDealsParams, *v14Market.ActivateDealsResult](rawParams, rawReturn, true) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parseGeneric[*v13Market.ActivateDealsParams, *v13Market.ActivateDealsResult](rawParams, rawReturn, true) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parseGeneric[*v12Market.ActivateDealsParams, *v12Market.ActivateDealsResult](rawParams, rawReturn, true) - case tools.V11.IsSupported(network, height): + case tools.V19.IsSupported(network, height): return parseGeneric[*v11Market.ActivateDealsParams, *v11Market.ActivateDealsResult](rawParams, rawReturn, true) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parseGeneric[*v10Market.ActivateDealsParams, *v10Market.ActivateDealsResult](rawParams, rawReturn, true) - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return parseGeneric[*v9Market.ActivateDealsParams, *v9Market.ActivateDealsResult](rawParams, rawReturn, true) } return nil, fmt.Errorf("unsupported height: %d", height) @@ -121,21 +121,21 @@ func ActivateDealsParams(network string, height int64, rawParams, rawReturn []by func OnMinerSectorsTerminateParams(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parseGeneric[*v15Market.OnMinerSectorsTerminateParams, *v15Market.OnMinerSectorsTerminateParams](rawParams, nil, false) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parseGeneric[*v14Market.OnMinerSectorsTerminateParams, *v14Market.OnMinerSectorsTerminateParams](rawParams, nil, false) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parseGeneric[*v13Market.OnMinerSectorsTerminateParams, *v13Market.OnMinerSectorsTerminateParams](rawParams, nil, false) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parseGeneric[*v12Market.OnMinerSectorsTerminateParams, *v12Market.OnMinerSectorsTerminateParams](rawParams, nil, false) - case tools.V11.IsSupported(network, height): + case tools.V19.IsSupported(network, height): return parseGeneric[*v11Market.OnMinerSectorsTerminateParams, *v11Market.OnMinerSectorsTerminateParams](rawParams, nil, false) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parseGeneric[*v10Market.OnMinerSectorsTerminateParams, *v10Market.OnMinerSectorsTerminateParams](rawParams, nil, false) - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return parseGeneric[*v9Market.OnMinerSectorsTerminateParams, *v9Market.OnMinerSectorsTerminateParams](rawParams, nil, false) - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): return parseGeneric[*v8Market.OnMinerSectorsTerminateParams, *v8Market.OnMinerSectorsTerminateParams](rawParams, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) @@ -143,13 +143,13 @@ func OnMinerSectorsTerminateParams(network string, height int64, rawParams []byt func ComputeDataCommitmentParams(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V11.IsSupported(network, height): + case tools.V19.IsSupported(network, height): return parseGeneric[*v11Market.ComputeDataCommitmentParams, *v11Market.ComputeDataCommitmentReturn](rawParams, rawReturn, true) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parseGeneric[*v10Market.ComputeDataCommitmentParams, *v10Market.ComputeDataCommitmentReturn](rawParams, rawReturn, true) - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return parseGeneric[*v9Market.ComputeDataCommitmentParams, *v9Market.ComputeDataCommitmentReturn](rawParams, rawReturn, true) - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): return parseGeneric[*v8Market.ComputeDataCommitmentParams, *v8Market.ComputeDataCommitmentReturn](rawParams, rawReturn, true) } return nil, fmt.Errorf("unsupported height: %d", height) @@ -157,17 +157,17 @@ func ComputeDataCommitmentParams(network string, height int64, rawParams, rawRet func GetBalanceParams(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parseGeneric[*address.Address, *v15Market.GetBalanceReturn](rawParams, rawReturn, true) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parseGeneric[*address.Address, *v14Market.GetBalanceReturn](rawParams, rawReturn, true) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parseGeneric[*address.Address, *v13Market.GetBalanceReturn](rawParams, rawReturn, true) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parseGeneric[*address.Address, *v12Market.GetBalanceReturn](rawParams, rawReturn, true) - case tools.V11.IsSupported(network, height): + case tools.V19.IsSupported(network, height): return parseGeneric[*address.Address, *v11Market.GetBalanceReturn](rawParams, rawReturn, true) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parseGeneric[*address.Address, *v10Market.GetBalanceReturn](rawParams, rawReturn, true) } return nil, fmt.Errorf("unsupported height: %d", height) @@ -175,17 +175,17 @@ func GetBalanceParams(network string, height int64, rawParams, rawReturn []byte) func GetDealDataCommitmentParams(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parseGeneric[*v15Market.GetDealDataCommitmentParams, *v15Market.GetDealDataCommitmentReturn](rawParams, rawReturn, true) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parseGeneric[*v14Market.GetDealDataCommitmentParams, *v14Market.GetDealDataCommitmentReturn](rawParams, rawReturn, true) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parseGeneric[*v13Market.GetDealDataCommitmentParams, *v13Market.GetDealDataCommitmentReturn](rawParams, rawReturn, true) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parseGeneric[*v12Market.GetDealDataCommitmentParams, *v12Market.GetDealDataCommitmentReturn](rawParams, rawReturn, true) - case tools.V11.IsSupported(network, height): + case tools.V19.IsSupported(network, height): return parseGeneric[*v11Market.GetDealDataCommitmentParams, *v11Market.GetDealDataCommitmentReturn](rawParams, rawReturn, true) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parseGeneric[*v10Market.GetDealDataCommitmentParams, *v10Market.GetDealDataCommitmentReturn](rawParams, rawReturn, true) } return nil, fmt.Errorf("unsupported height: %d", height) @@ -193,17 +193,17 @@ func GetDealDataCommitmentParams(network string, height int64, rawParams, rawRet func GetDealClientParams(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parseGeneric[*v15Market.GetDealClientParams, *v15Market.GetDealClientReturn](rawParams, rawReturn, true) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parseGeneric[*v14Market.GetDealClientParams, *v14Market.GetDealClientReturn](rawParams, rawReturn, true) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parseGeneric[*v13Market.GetDealClientParams, *v13Market.GetDealClientReturn](rawParams, rawReturn, true) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parseGeneric[*v12Market.GetDealClientParams, *v12Market.GetDealClientReturn](rawParams, rawReturn, true) - case tools.V11.IsSupported(network, height): + case tools.V19.IsSupported(network, height): return parseGeneric[*v11Market.GetDealClientParams, *v11Market.GetDealClientReturn](rawParams, rawReturn, true) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parseGeneric[*v10Market.GetDealClientParams, *v10Market.GetDealClientReturn](rawParams, rawReturn, true) } return nil, fmt.Errorf("unsupported height: %d", height) @@ -211,17 +211,17 @@ func GetDealClientParams(network string, height int64, rawParams, rawReturn []by func GetDealProviderParams(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parseGeneric[*v15Market.GetDealProviderParams, *v15Market.GetDealProviderReturn](rawParams, rawReturn, true) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parseGeneric[*v14Market.GetDealProviderParams, *v14Market.GetDealProviderReturn](rawParams, rawReturn, true) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parseGeneric[*v13Market.GetDealProviderParams, *v13Market.GetDealProviderReturn](rawParams, rawReturn, true) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parseGeneric[*v12Market.GetDealProviderParams, *v12Market.GetDealProviderReturn](rawParams, rawReturn, true) - case tools.V11.IsSupported(network, height): + case tools.V19.IsSupported(network, height): return parseGeneric[*v11Market.GetDealProviderParams, *v11Market.GetDealProviderReturn](rawParams, rawReturn, true) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parseGeneric[*v10Market.GetDealProviderParams, *v10Market.GetDealProviderReturn](rawParams, rawReturn, true) } return nil, fmt.Errorf("unsupported height: %d", height) @@ -229,17 +229,17 @@ func GetDealProviderParams(network string, height int64, rawParams, rawReturn [] func GetDealLabelParams(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parseGeneric[*v15Market.GetDealLabelParams, *v15Market.GetDealLabelReturn](rawParams, rawReturn, true) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parseGeneric[*v14Market.GetDealLabelParams, *v14Market.GetDealLabelReturn](rawParams, rawReturn, true) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parseGeneric[*v13Market.GetDealLabelParams, *v13Market.GetDealLabelReturn](rawParams, rawReturn, true) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parseGeneric[*v12Market.GetDealLabelParams, *v12Market.GetDealLabelReturn](rawParams, rawReturn, true) - case tools.V11.IsSupported(network, height): + case tools.V19.IsSupported(network, height): return parseGeneric[*v11Market.GetDealLabelParams, *v11Market.GetDealLabelReturn](rawParams, rawReturn, true) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parseGeneric[*v10Market.GetDealLabelParams, *v10Market.GetDealLabelReturn](rawParams, rawReturn, true) } return nil, fmt.Errorf("unsupported height: %d", height) @@ -247,17 +247,17 @@ func GetDealLabelParams(network string, height int64, rawParams, rawReturn []byt func GetDealTermParams(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parseGeneric[*v15Market.GetDealTermParams, *v15Market.GetDealTermReturn](rawParams, rawReturn, true) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parseGeneric[*v14Market.GetDealTermParams, *v14Market.GetDealTermReturn](rawParams, rawReturn, true) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parseGeneric[*v13Market.GetDealTermParams, *v13Market.GetDealTermReturn](rawParams, rawReturn, true) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parseGeneric[*v12Market.GetDealTermParams, *v12Market.GetDealTermReturn](rawParams, rawReturn, true) - case tools.V11.IsSupported(network, height): + case tools.V19.IsSupported(network, height): return parseGeneric[*v11Market.GetDealTermParams, *v11Market.GetDealTermReturn](rawParams, rawReturn, true) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parseGeneric[*v10Market.GetDealTermParams, *v10Market.GetDealTermReturn](rawParams, rawReturn, true) } return nil, fmt.Errorf("unsupported height: %d", height) @@ -265,17 +265,17 @@ func GetDealTermParams(network string, height int64, rawParams, rawReturn []byte func GetDealTotalPriceParams(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parseGeneric[*v15Market.GetDealTotalPriceParams, *v15Market.GetDealTotalPriceReturn](rawParams, rawReturn, true) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parseGeneric[*v14Market.GetDealTotalPriceParams, *v14Market.GetDealTotalPriceReturn](rawParams, rawReturn, true) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parseGeneric[*v13Market.GetDealTotalPriceParams, *v13Market.GetDealTotalPriceReturn](rawParams, rawReturn, true) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parseGeneric[*v12Market.GetDealTotalPriceParams, *v12Market.GetDealTotalPriceReturn](rawParams, rawReturn, true) - case tools.V11.IsSupported(network, height): + case tools.V19.IsSupported(network, height): return parseGeneric[*v11Market.GetDealTotalPriceParams, *v11Market.GetDealTotalPriceReturn](rawParams, rawReturn, true) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parseGeneric[*v10Market.GetDealTotalPriceParams, *v10Market.GetDealTotalPriceReturn](rawParams, rawReturn, true) } return nil, fmt.Errorf("unsupported height: %d", height) @@ -283,17 +283,17 @@ func GetDealTotalPriceParams(network string, height int64, rawParams, rawReturn func GetDealClientCollateralParams(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parseGeneric[*v15Market.GetDealClientCollateralParams, *v15Market.GetDealClientCollateralReturn](rawParams, rawReturn, true) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parseGeneric[*v14Market.GetDealClientCollateralParams, *v14Market.GetDealClientCollateralReturn](rawParams, rawReturn, true) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parseGeneric[*v13Market.GetDealClientCollateralParams, *v13Market.GetDealClientCollateralReturn](rawParams, rawReturn, true) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parseGeneric[*v12Market.GetDealClientCollateralParams, *v12Market.GetDealClientCollateralReturn](rawParams, rawReturn, true) - case tools.V11.IsSupported(network, height): + case tools.V19.IsSupported(network, height): return parseGeneric[*v11Market.GetDealClientCollateralParams, *v11Market.GetDealClientCollateralReturn](rawParams, rawReturn, true) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parseGeneric[*v10Market.GetDealClientCollateralParams, *v10Market.GetDealClientCollateralReturn](rawParams, rawReturn, true) } return nil, fmt.Errorf("unsupported height: %d", height) @@ -301,17 +301,17 @@ func GetDealClientCollateralParams(network string, height int64, rawParams, rawR func GetDealProviderCollateralParams(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parseGeneric[*v15Market.GetDealProviderCollateralParams, *v15Market.GetDealProviderCollateralReturn](rawParams, rawReturn, true) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parseGeneric[*v14Market.GetDealProviderCollateralParams, *v14Market.GetDealProviderCollateralReturn](rawParams, rawReturn, true) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parseGeneric[*v13Market.GetDealProviderCollateralParams, *v13Market.GetDealProviderCollateralReturn](rawParams, rawReturn, true) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parseGeneric[*v12Market.GetDealProviderCollateralParams, *v12Market.GetDealProviderCollateralReturn](rawParams, rawReturn, true) - case tools.V11.IsSupported(network, height): + case tools.V19.IsSupported(network, height): return parseGeneric[*v11Market.GetDealProviderCollateralParams, *v11Market.GetDealProviderCollateralReturn](rawParams, rawReturn, true) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parseGeneric[*v10Market.GetDealProviderCollateralParams, *v10Market.GetDealProviderCollateralReturn](rawParams, rawReturn, true) } return nil, fmt.Errorf("unsupported height: %d", height) @@ -319,17 +319,17 @@ func GetDealProviderCollateralParams(network string, height int64, rawParams, ra func GetDealVerifiedParams(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parseGeneric[*v15Market.GetDealVerifiedParams, *v15Market.GetDealVerifiedReturn](rawParams, rawReturn, true) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parseGeneric[*v14Market.GetDealVerifiedParams, *v14Market.GetDealVerifiedReturn](rawParams, rawReturn, true) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parseGeneric[*v13Market.GetDealVerifiedParams, *v13Market.GetDealVerifiedReturn](rawParams, rawReturn, true) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parseGeneric[*v12Market.GetDealVerifiedParams, *v12Market.GetDealVerifiedReturn](rawParams, rawReturn, true) - case tools.V11.IsSupported(network, height): + case tools.V19.IsSupported(network, height): return parseGeneric[*v11Market.GetDealVerifiedParams, *v11Market.GetDealVerifiedReturn](rawParams, rawReturn, true) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parseGeneric[*v10Market.GetDealVerifiedParams, *v10Market.GetDealVerifiedReturn](rawParams, rawReturn, true) } return nil, fmt.Errorf("unsupported height: %d", height) @@ -337,17 +337,17 @@ func GetDealVerifiedParams(network string, height int64, rawParams, rawReturn [] func GetDealActivationParams(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parseGeneric[*v15Market.GetDealActivationParams, *v15Market.GetDealActivationReturn](rawParams, rawReturn, true) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parseGeneric[*v14Market.GetDealActivationParams, *v14Market.GetDealActivationReturn](rawParams, rawReturn, true) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parseGeneric[*v13Market.GetDealActivationParams, *v13Market.GetDealActivationReturn](rawParams, rawReturn, true) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parseGeneric[*v12Market.GetDealActivationParams, *v12Market.GetDealActivationReturn](rawParams, rawReturn, true) - case tools.V11.IsSupported(network, height): + case tools.V19.IsSupported(network, height): return parseGeneric[*v11Market.GetDealActivationParams, *v11Market.GetDealActivationReturn](rawParams, rawReturn, true) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parseGeneric[*v10Market.GetDealActivationParams, *v10Market.GetDealActivationReturn](rawParams, rawReturn, true) } return nil, fmt.Errorf("unsupported height: %d", height) diff --git a/actors/miner/address.go b/actors/miner/address.go index 41184641..985a47bb 100644 --- a/actors/miner/address.go +++ b/actors/miner/address.go @@ -17,21 +17,21 @@ import ( func ChangeMultiaddrs(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parseGeneric[*miner15.ChangeMultiaddrsParams, *miner15.ChangeMultiaddrsParams](rawParams, nil, false) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parseGeneric[*miner14.ChangeMultiaddrsParams, *miner14.ChangeMultiaddrsParams](rawParams, nil, false) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parseGeneric[*miner13.ChangeMultiaddrsParams, *miner13.ChangeMultiaddrsParams](rawParams, nil, false) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parseGeneric[*miner12.ChangeMultiaddrsParams, *miner12.ChangeMultiaddrsParams](rawParams, nil, false) - case tools.V11.IsSupported(network, height): + case tools.V20.IsSupported(network, height): return parseGeneric[*miner11.ChangeMultiaddrsParams, *miner11.ChangeMultiaddrsParams](rawParams, nil, false) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parseGeneric[*miner10.ChangeMultiaddrsParams, *miner10.ChangeMultiaddrsParams](rawParams, nil, false) - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return parseGeneric[*miner9.ChangeMultiaddrsParams, *miner9.ChangeMultiaddrsParams](rawParams, nil, false) - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): return parseGeneric[*miner8.ChangeMultiaddrsParams, *miner8.ChangeMultiaddrsParams](rawParams, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) @@ -39,21 +39,21 @@ func ChangeMultiaddrs(network string, height int64, rawParams []byte) (map[strin func ChangePeerID(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parseGeneric[*miner15.ChangePeerIDParams, *miner15.ChangePeerIDParams](rawParams, nil, false) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parseGeneric[*miner14.ChangePeerIDParams, *miner14.ChangePeerIDParams](rawParams, nil, false) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parseGeneric[*miner13.ChangePeerIDParams, *miner13.ChangePeerIDParams](rawParams, nil, false) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parseGeneric[*miner12.ChangePeerIDParams, *miner12.ChangePeerIDParams](rawParams, nil, false) - case tools.V11.IsSupported(network, height): + case tools.V20.IsSupported(network, height): return parseGeneric[*miner11.ChangePeerIDParams, *miner11.ChangePeerIDParams](rawParams, nil, false) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parseGeneric[*miner10.ChangePeerIDParams, *miner10.ChangePeerIDParams](rawParams, nil, false) - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return parseGeneric[*miner9.ChangePeerIDParams, *miner9.ChangePeerIDParams](rawParams, nil, false) - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): return parseGeneric[*miner8.ChangePeerIDParams, *miner8.ChangePeerIDParams](rawParams, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) @@ -61,21 +61,21 @@ func ChangePeerID(network string, height int64, rawParams []byte) (map[string]in func ChangeWorkerAddress(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parseGeneric[*miner15.ChangeWorkerAddressParams, *miner15.ChangeWorkerAddressParams](rawParams, nil, false) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parseGeneric[*miner14.ChangeWorkerAddressParams, *miner14.ChangeWorkerAddressParams](rawParams, nil, false) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parseGeneric[*miner13.ChangeWorkerAddressParams, *miner13.ChangeWorkerAddressParams](rawParams, nil, false) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parseGeneric[*miner12.ChangeWorkerAddressParams, *miner12.ChangeWorkerAddressParams](rawParams, nil, false) - case tools.V11.IsSupported(network, height): + case tools.V20.IsSupported(network, height): return parseGeneric[*miner11.ChangeWorkerAddressParams, *miner11.ChangeWorkerAddressParams](rawParams, nil, false) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parseGeneric[*miner10.ChangeWorkerAddressParams, *miner10.ChangeWorkerAddressParams](rawParams, nil, false) - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return parseGeneric[*miner9.ChangeWorkerAddressParams, *miner9.ChangeWorkerAddressParams](rawParams, nil, false) - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): return parseGeneric[*miner8.ChangeWorkerAddressParams, *miner8.ChangeWorkerAddressParams](rawParams, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) @@ -83,21 +83,21 @@ func ChangeWorkerAddress(network string, height int64, rawParams []byte) (map[st func ChangeOwnerAddress(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parseGeneric[*address.Address, *address.Address](rawParams, nil, false) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parseGeneric[*address.Address, *address.Address](rawParams, nil, false) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parseGeneric[*address.Address, *address.Address](rawParams, nil, false) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parseGeneric[*address.Address, *address.Address](rawParams, nil, false) - case tools.V11.IsSupported(network, height): + case tools.V20.IsSupported(network, height): return parseGeneric[*address.Address, *address.Address](rawParams, nil, false) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parseGeneric[*address.Address, *address.Address](rawParams, nil, false) - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return parseGeneric[*address.Address, *address.Address](rawParams, nil, false) - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): return parseGeneric[*address.Address, *address.Address](rawParams, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) @@ -105,21 +105,21 @@ func ChangeOwnerAddress(network string, height int64, rawParams []byte) (map[str func IsControllingAddressExported(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parseGeneric[*miner15.IsControllingAddressParams, *miner15.IsControllingAddressReturn](rawParams, rawReturn, true) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parseGeneric[*miner14.IsControllingAddressParams, *miner14.IsControllingAddressReturn](rawParams, rawReturn, true) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parseGeneric[*miner13.IsControllingAddressParams, *miner13.IsControllingAddressReturn](rawParams, rawReturn, true) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parseGeneric[*miner12.IsControllingAddressParams, *miner12.IsControllingAddressReturn](rawParams, rawReturn, true) - case tools.V11.IsSupported(network, height): + case tools.V20.IsSupported(network, height): return parseGeneric[*miner11.IsControllingAddressParams, *miner11.IsControllingAddressReturn](rawParams, rawReturn, true) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parseGeneric[*miner10.IsControllingAddressParams, *miner10.IsControllingAddressReturn](rawParams, rawReturn, true) - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return nil, fmt.Errorf("not supported") - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): return nil, fmt.Errorf("not supported") } return nil, fmt.Errorf("unsupported height: %d", height) @@ -127,21 +127,21 @@ func IsControllingAddressExported(network string, height int64, rawParams, rawRe func GetOwner(network string, height int64, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parseGeneric[*miner15.GetOwnerReturn, *miner15.GetOwnerReturn](rawReturn, nil, false) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parseGeneric[*miner14.GetOwnerReturn, *miner14.GetOwnerReturn](rawReturn, nil, false) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parseGeneric[*miner13.GetOwnerReturn, *miner13.GetOwnerReturn](rawReturn, nil, false) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parseGeneric[*miner12.GetOwnerReturn, *miner12.GetOwnerReturn](rawReturn, nil, false) - case tools.V11.IsSupported(network, height): + case tools.V20.IsSupported(network, height): return parseGeneric[*miner11.GetOwnerReturn, *miner11.GetOwnerReturn](rawReturn, nil, false) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parseGeneric[*miner10.GetOwnerReturn, *miner10.GetOwnerReturn](rawReturn, nil, false) - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return nil, fmt.Errorf("not supported") - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): return nil, fmt.Errorf("not supported") } return nil, fmt.Errorf("unsupported height: %d", height) @@ -149,21 +149,21 @@ func GetOwner(network string, height int64, rawReturn []byte) (map[string]interf func GetPeerID(network string, height int64, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parseGeneric[*miner15.GetPeerIDReturn, *miner15.GetPeerIDReturn](rawReturn, nil, false) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parseGeneric[*miner14.GetPeerIDReturn, *miner14.GetPeerIDReturn](rawReturn, nil, false) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parseGeneric[*miner13.GetPeerIDReturn, *miner13.GetPeerIDReturn](rawReturn, nil, false) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parseGeneric[*miner12.GetPeerIDReturn, *miner12.GetPeerIDReturn](rawReturn, nil, false) - case tools.V11.IsSupported(network, height): + case tools.V20.IsSupported(network, height): return parseGeneric[*miner11.GetPeerIDReturn, *miner11.GetPeerIDReturn](rawReturn, nil, false) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parseGeneric[*miner10.GetPeerIDReturn, *miner10.GetPeerIDReturn](rawReturn, nil, false) - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return nil, fmt.Errorf("not supported") - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): return nil, fmt.Errorf("not supported") } return nil, fmt.Errorf("unsupported height: %d", height) @@ -171,21 +171,21 @@ func GetPeerID(network string, height int64, rawReturn []byte) (map[string]inter func GetMultiaddrs(network string, height int64, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parseGeneric[*miner15.GetMultiAddrsReturn, *miner15.GetMultiAddrsReturn](rawReturn, nil, false) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parseGeneric[*miner14.GetMultiAddrsReturn, *miner14.GetMultiAddrsReturn](rawReturn, nil, false) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parseGeneric[*miner13.GetMultiAddrsReturn, *miner13.GetMultiAddrsReturn](rawReturn, nil, false) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parseGeneric[*miner12.GetMultiAddrsReturn, *miner12.GetMultiAddrsReturn](rawReturn, nil, false) - case tools.V11.IsSupported(network, height): + case tools.V20.IsSupported(network, height): return parseGeneric[*miner11.GetMultiAddrsReturn, *miner11.GetMultiAddrsReturn](rawReturn, nil, false) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parseGeneric[*miner10.GetMultiAddrsReturn, *miner10.GetMultiAddrsReturn](rawReturn, nil, false) - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return nil, fmt.Errorf("not supported") - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): return nil, fmt.Errorf("not supported") } return nil, fmt.Errorf("unsupported height: %d", height) diff --git a/actors/miner/balance.go b/actors/miner/balance.go index 815863af..b83362cc 100644 --- a/actors/miner/balance.go +++ b/actors/miner/balance.go @@ -16,21 +16,21 @@ import ( func GetAvailableBalance(network string, height int64, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parseGeneric[*miner15.GetAvailableBalanceReturn, *miner15.GetAvailableBalanceReturn](rawReturn, nil, false) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parseGeneric[*miner14.GetAvailableBalanceReturn, *miner14.GetAvailableBalanceReturn](rawReturn, nil, false) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parseGeneric[*miner13.GetAvailableBalanceReturn, *miner13.GetAvailableBalanceReturn](rawReturn, nil, false) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parseGeneric[*miner12.GetAvailableBalanceReturn, *miner12.GetAvailableBalanceReturn](rawReturn, nil, false) - case tools.V11.IsSupported(network, height): + case tools.V20.IsSupported(network, height): return parseGeneric[*miner11.GetAvailableBalanceReturn, *miner11.GetAvailableBalanceReturn](rawReturn, nil, false) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parseGeneric[*miner10.GetAvailableBalanceReturn, *miner10.GetAvailableBalanceReturn](rawReturn, nil, false) - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return nil, fmt.Errorf("not supported") - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): return nil, fmt.Errorf("not supported") } return nil, fmt.Errorf("unsupported height: %d", height) @@ -38,21 +38,21 @@ func GetAvailableBalance(network string, height int64, rawReturn []byte) (map[st func GetVestingFunds(network string, height int64, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parseGeneric[*miner15.GetVestingFundsReturn, *miner15.GetVestingFundsReturn](rawReturn, nil, false) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parseGeneric[*miner14.GetVestingFundsReturn, *miner14.GetVestingFundsReturn](rawReturn, nil, false) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parseGeneric[*miner13.GetVestingFundsReturn, *miner13.GetVestingFundsReturn](rawReturn, nil, false) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parseGeneric[*miner12.GetVestingFundsReturn, *miner12.GetVestingFundsReturn](rawReturn, nil, false) - case tools.V11.IsSupported(network, height): + case tools.V20.IsSupported(network, height): return parseGeneric[*miner11.GetVestingFundsReturn, *miner11.GetVestingFundsReturn](rawReturn, nil, false) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parseGeneric[*miner10.GetVestingFundsReturn, *miner10.GetVestingFundsReturn](rawReturn, nil, false) - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return nil, fmt.Errorf("not supported") - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): return nil, fmt.Errorf("not supported") } return nil, fmt.Errorf("unsupported height: %d", height) @@ -60,21 +60,21 @@ func GetVestingFunds(network string, height int64, rawReturn []byte) (map[string func ParseWithdrawBalance(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parseGeneric[*miner15.WithdrawBalanceParams, *miner15.WithdrawBalanceParams](rawParams, nil, false) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parseGeneric[*miner14.WithdrawBalanceParams, *miner14.WithdrawBalanceParams](rawParams, nil, false) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parseGeneric[*miner13.WithdrawBalanceParams, *miner13.WithdrawBalanceParams](rawParams, nil, false) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parseGeneric[*miner12.WithdrawBalanceParams, *miner12.WithdrawBalanceParams](rawParams, nil, false) - case tools.V11.IsSupported(network, height): + case tools.V20.IsSupported(network, height): return parseGeneric[*miner11.WithdrawBalanceParams, *miner11.WithdrawBalanceParams](rawParams, nil, false) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parseGeneric[*miner10.WithdrawBalanceParams, *miner10.WithdrawBalanceParams](rawParams, nil, false) - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return parseGeneric[*miner9.WithdrawBalanceParams, *miner9.WithdrawBalanceParams](rawParams, nil, false) - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): return parseGeneric[*miner8.WithdrawBalanceParams, *miner8.WithdrawBalanceParams](rawParams, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) diff --git a/actors/miner/miner.go b/actors/miner/miner.go index d80f5d89..9fa67ace 100644 --- a/actors/miner/miner.go +++ b/actors/miner/miner.go @@ -16,21 +16,21 @@ import ( func TerminateSectors(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parseGeneric[*miner15.TerminateSectorsParams, *miner15.TerminateSectorsReturn](rawParams, rawReturn, true) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parseGeneric[*miner14.TerminateSectorsParams, *miner14.TerminateSectorsReturn](rawParams, rawReturn, true) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parseGeneric[*miner13.TerminateSectorsParams, *miner13.TerminateSectorsReturn](rawParams, rawReturn, true) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parseGeneric[*miner12.TerminateSectorsParams, *miner12.TerminateSectorsReturn](rawParams, rawReturn, true) - case tools.V11.IsSupported(network, height): + case tools.V20.IsSupported(network, height): return parseGeneric[*miner11.TerminateSectorsParams, *miner11.TerminateSectorsReturn](rawParams, rawReturn, true) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parseGeneric[*miner10.TerminateSectorsParams, *miner10.TerminateSectorsReturn](rawParams, rawReturn, true) - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return parseGeneric[*miner9.TerminateSectorsParams, *miner9.TerminateSectorsReturn](rawParams, rawReturn, true) - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): return parseGeneric[*miner8.TerminateSectorsParams, *miner8.TerminateSectorsReturn](rawParams, rawReturn, true) } return nil, fmt.Errorf("unsupported height: %d", height) @@ -38,21 +38,21 @@ func TerminateSectors(network string, height int64, rawParams, rawReturn []byte) func DeclareFaults(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parseGeneric[*miner15.DeclareFaultsParams, *miner15.DeclareFaultsParams](rawParams, nil, false) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parseGeneric[*miner14.DeclareFaultsParams, *miner14.DeclareFaultsParams](rawParams, nil, false) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parseGeneric[*miner13.DeclareFaultsParams, *miner13.DeclareFaultsParams](rawParams, nil, false) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parseGeneric[*miner12.DeclareFaultsParams, *miner12.DeclareFaultsParams](rawParams, nil, false) - case tools.V11.IsSupported(network, height): + case tools.V20.IsSupported(network, height): return parseGeneric[*miner11.DeclareFaultsParams, *miner11.DeclareFaultsParams](rawParams, nil, false) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parseGeneric[*miner10.DeclareFaultsParams, *miner10.DeclareFaultsParams](rawParams, nil, false) - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return parseGeneric[*miner9.DeclareFaultsParams, *miner9.DeclareFaultsParams](rawParams, nil, false) - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): return parseGeneric[*miner8.DeclareFaultsParams, *miner8.DeclareFaultsParams](rawParams, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) @@ -60,21 +60,21 @@ func DeclareFaults(network string, height int64, rawParams []byte) (map[string]i func DeclareFaultsRecovered(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parseGeneric[*miner15.DeclareFaultsRecoveredParams, *miner15.DeclareFaultsRecoveredParams](rawParams, nil, false) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parseGeneric[*miner14.DeclareFaultsRecoveredParams, *miner14.DeclareFaultsRecoveredParams](rawParams, nil, false) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parseGeneric[*miner13.DeclareFaultsRecoveredParams, *miner13.DeclareFaultsRecoveredParams](rawParams, nil, false) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parseGeneric[*miner12.DeclareFaultsRecoveredParams, *miner12.DeclareFaultsRecoveredParams](rawParams, nil, false) - case tools.V11.IsSupported(network, height): + case tools.V20.IsSupported(network, height): return parseGeneric[*miner11.DeclareFaultsRecoveredParams, *miner11.DeclareFaultsRecoveredParams](rawParams, nil, false) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parseGeneric[*miner10.DeclareFaultsRecoveredParams, *miner10.DeclareFaultsRecoveredParams](rawParams, nil, false) - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return parseGeneric[*miner9.DeclareFaultsRecoveredParams, *miner9.DeclareFaultsRecoveredParams](rawParams, nil, false) - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): return parseGeneric[*miner8.DeclareFaultsRecoveredParams, *miner8.DeclareFaultsRecoveredParams](rawParams, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) @@ -82,21 +82,21 @@ func DeclareFaultsRecovered(network string, height int64, rawParams []byte) (map func ProveReplicaUpdates(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parseGeneric[*miner15.ProveReplicaUpdatesParams, *miner15.ProveReplicaUpdatesParams](rawParams, nil, false) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parseGeneric[*miner14.ProveReplicaUpdatesParams, *miner14.ProveReplicaUpdatesParams](rawParams, nil, false) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parseGeneric[*miner13.ProveReplicaUpdatesParams, *miner13.ProveReplicaUpdatesParams](rawParams, nil, false) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parseGeneric[*miner12.ProveReplicaUpdatesParams, *miner12.ProveReplicaUpdatesParams](rawParams, nil, false) - case tools.V11.IsSupported(network, height): + case tools.V20.IsSupported(network, height): return parseGeneric[*miner11.ProveReplicaUpdatesParams, *miner11.ProveReplicaUpdatesParams](rawParams, nil, false) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parseGeneric[*miner10.ProveReplicaUpdatesParams, *miner10.ProveReplicaUpdatesParams](rawParams, nil, false) - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return parseGeneric[*miner9.ProveReplicaUpdatesParams, *miner9.ProveReplicaUpdatesParams](rawParams, nil, false) - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): return parseGeneric[*miner8.ProveReplicaUpdatesParams, *miner8.ProveReplicaUpdatesParams](rawParams, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) @@ -104,21 +104,21 @@ func ProveReplicaUpdates(network string, height int64, rawParams []byte) (map[st func PreCommitSectorBatch2(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parseGeneric[*miner15.PreCommitSectorBatchParams2, *miner15.PreCommitSectorBatchParams2](rawParams, nil, false) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parseGeneric[*miner14.PreCommitSectorBatchParams2, *miner14.PreCommitSectorBatchParams2](rawParams, nil, false) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parseGeneric[*miner13.PreCommitSectorBatchParams2, *miner13.PreCommitSectorBatchParams2](rawParams, nil, false) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parseGeneric[*miner12.PreCommitSectorBatchParams2, *miner12.PreCommitSectorBatchParams2](rawParams, nil, false) - case tools.V11.IsSupported(network, height): + case tools.V20.IsSupported(network, height): return parseGeneric[*miner11.PreCommitSectorBatchParams2, *miner11.PreCommitSectorBatchParams2](rawParams, nil, false) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parseGeneric[*miner10.PreCommitSectorBatchParams2, *miner10.PreCommitSectorBatchParams2](rawParams, nil, false) - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return parseGeneric[*miner9.PreCommitSectorBatchParams2, *miner9.PreCommitSectorBatchParams2](rawParams, nil, false) - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): return nil, fmt.Errorf("unsupported height: %d", height) } return nil, fmt.Errorf("unsupported height: %d", height) @@ -126,21 +126,21 @@ func PreCommitSectorBatch2(network string, height int64, rawParams []byte) (map[ func ProveReplicaUpdates2(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parseGeneric[*miner15.ProveReplicaUpdatesParams2, *miner15.ProveReplicaUpdatesParams2](rawParams, rawReturn, true) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parseGeneric[*miner14.ProveReplicaUpdatesParams2, *miner14.ProveReplicaUpdatesParams2](rawParams, rawReturn, true) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parseGeneric[*miner13.ProveReplicaUpdatesParams2, *miner13.ProveReplicaUpdatesParams2](rawParams, rawReturn, true) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parseGeneric[*miner12.ProveReplicaUpdatesParams2, *miner12.ProveReplicaUpdatesParams2](rawParams, rawReturn, true) - case tools.V11.IsSupported(network, height): + case tools.V20.IsSupported(network, height): return parseGeneric[*miner11.ProveReplicaUpdatesParams2, *miner11.ProveReplicaUpdatesParams2](rawParams, rawReturn, true) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parseGeneric[*miner10.ProveReplicaUpdatesParams2, *miner10.ProveReplicaUpdatesParams2](rawParams, rawReturn, true) - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return parseGeneric[*miner9.ProveReplicaUpdatesParams2, *miner9.ProveReplicaUpdatesParams2](rawParams, rawReturn, true) - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): return nil, fmt.Errorf("unsupported height: %d", height) } return nil, fmt.Errorf("unsupported height: %d", height) @@ -148,21 +148,21 @@ func ProveReplicaUpdates2(network string, height int64, rawParams, rawReturn []b func ProveCommitAggregate(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parseGeneric[*miner15.ProveCommitAggregateParams, *miner15.ProveCommitAggregateParams](rawParams, nil, false) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parseGeneric[*miner14.ProveCommitAggregateParams, *miner14.ProveCommitAggregateParams](rawParams, nil, false) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parseGeneric[*miner13.ProveCommitAggregateParams, *miner13.ProveCommitAggregateParams](rawParams, nil, false) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parseGeneric[*miner12.ProveCommitAggregateParams, *miner12.ProveCommitAggregateParams](rawParams, nil, false) - case tools.V11.IsSupported(network, height): + case tools.V20.IsSupported(network, height): return parseGeneric[*miner11.ProveCommitAggregateParams, *miner11.ProveCommitAggregateParams](rawParams, nil, false) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parseGeneric[*miner10.ProveCommitAggregateParams, *miner10.ProveCommitAggregateParams](rawParams, nil, false) - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return parseGeneric[*miner9.ProveCommitAggregateParams, *miner9.ProveCommitAggregateParams](rawParams, nil, false) - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): return parseGeneric[*miner8.ProveCommitAggregateParams, *miner8.ProveCommitAggregateParams](rawParams, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) @@ -170,21 +170,21 @@ func ProveCommitAggregate(network string, height int64, rawParams []byte) (map[s func DisputeWindowedPoSt(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parseGeneric[*miner15.DisputeWindowedPoStParams, *miner15.DisputeWindowedPoStParams](rawParams, nil, false) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parseGeneric[*miner14.DisputeWindowedPoStParams, *miner14.DisputeWindowedPoStParams](rawParams, nil, false) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parseGeneric[*miner13.DisputeWindowedPoStParams, *miner13.DisputeWindowedPoStParams](rawParams, nil, false) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parseGeneric[*miner12.DisputeWindowedPoStParams, *miner12.DisputeWindowedPoStParams](rawParams, nil, false) - case tools.V11.IsSupported(network, height): + case tools.V20.IsSupported(network, height): return parseGeneric[*miner11.DisputeWindowedPoStParams, *miner11.DisputeWindowedPoStParams](rawParams, nil, false) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parseGeneric[*miner10.DisputeWindowedPoStParams, *miner10.DisputeWindowedPoStParams](rawParams, nil, false) - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return parseGeneric[*miner9.DisputeWindowedPoStParams, *miner9.DisputeWindowedPoStParams](rawParams, nil, false) - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): return parseGeneric[*miner8.DisputeWindowedPoStParams, *miner8.DisputeWindowedPoStParams](rawParams, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) @@ -192,21 +192,21 @@ func DisputeWindowedPoSt(network string, height int64, rawParams []byte) (map[st func ReportConsensusFault(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parseGeneric[*miner15.ReportConsensusFaultParams, *miner15.ReportConsensusFaultParams](rawParams, nil, false) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parseGeneric[*miner14.ReportConsensusFaultParams, *miner14.ReportConsensusFaultParams](rawParams, nil, false) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parseGeneric[*miner13.ReportConsensusFaultParams, *miner13.ReportConsensusFaultParams](rawParams, nil, false) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parseGeneric[*miner12.ReportConsensusFaultParams, *miner12.ReportConsensusFaultParams](rawParams, nil, false) - case tools.V11.IsSupported(network, height): + case tools.V20.IsSupported(network, height): return parseGeneric[*miner11.ReportConsensusFaultParams, *miner11.ReportConsensusFaultParams](rawParams, nil, false) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parseGeneric[*miner10.ReportConsensusFaultParams, *miner10.ReportConsensusFaultParams](rawParams, nil, false) - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return parseGeneric[*miner9.ReportConsensusFaultParams, *miner9.ReportConsensusFaultParams](rawParams, nil, false) - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): return parseGeneric[*miner8.ReportConsensusFaultParams, *miner8.ReportConsensusFaultParams](rawParams, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) @@ -214,21 +214,21 @@ func ReportConsensusFault(network string, height int64, rawParams []byte) (map[s func ChangeBeneficiary(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parseGeneric[*miner15.ChangeBeneficiaryParams, *miner15.ChangeBeneficiaryParams](rawParams, nil, false) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parseGeneric[*miner14.ChangeBeneficiaryParams, *miner14.ChangeBeneficiaryParams](rawParams, nil, false) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parseGeneric[*miner13.ChangeBeneficiaryParams, *miner13.ChangeBeneficiaryParams](rawParams, nil, false) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parseGeneric[*miner12.ChangeBeneficiaryParams, *miner12.ChangeBeneficiaryParams](rawParams, nil, false) - case tools.V11.IsSupported(network, height): + case tools.V20.IsSupported(network, height): return parseGeneric[*miner11.ChangeBeneficiaryParams, *miner11.ChangeBeneficiaryParams](rawParams, nil, false) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parseGeneric[*miner10.ChangeBeneficiaryParams, *miner10.ChangeBeneficiaryParams](rawParams, nil, false) - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return parseGeneric[*miner9.ChangeBeneficiaryParams, *miner9.ChangeBeneficiaryParams](rawParams, nil, false) - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): return nil, fmt.Errorf("not supported") } return nil, fmt.Errorf("unsupported height: %d", height) @@ -236,21 +236,21 @@ func ChangeBeneficiary(network string, height int64, rawParams []byte) (map[stri func MinerConstructor(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parseGeneric[*miner15.MinerConstructorParams, *miner15.MinerConstructorParams](rawParams, nil, false) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parseGeneric[*miner14.MinerConstructorParams, *miner14.MinerConstructorParams](rawParams, nil, false) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parseGeneric[*miner13.MinerConstructorParams, *miner13.MinerConstructorParams](rawParams, nil, false) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parseGeneric[*miner12.MinerConstructorParams, *miner12.MinerConstructorParams](rawParams, nil, false) - case tools.V11.IsSupported(network, height): + case tools.V20.IsSupported(network, height): return parseGeneric[*miner11.MinerConstructorParams, *miner11.MinerConstructorParams](rawParams, nil, false) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parseGeneric[*miner10.MinerConstructorParams, *miner10.MinerConstructorParams](rawParams, nil, false) - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return parseGeneric[*miner9.MinerConstructorParams, *miner9.MinerConstructorParams](rawParams, nil, false) - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): return parseGeneric[*miner8.MinerConstructorParams, *miner8.MinerConstructorParams](rawParams, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) @@ -258,21 +258,21 @@ func MinerConstructor(network string, height int64, rawParams []byte) (map[strin func ApplyRewards(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parseGeneric[*miner15.ApplyRewardParams, *miner15.ApplyRewardParams](rawParams, nil, false) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parseGeneric[*miner14.ApplyRewardParams, *miner14.ApplyRewardParams](rawParams, nil, false) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parseGeneric[*miner13.ApplyRewardParams, *miner13.ApplyRewardParams](rawParams, nil, false) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parseGeneric[*miner12.ApplyRewardParams, *miner12.ApplyRewardParams](rawParams, nil, false) - case tools.V11.IsSupported(network, height): + case tools.V20.IsSupported(network, height): return parseGeneric[*miner11.ApplyRewardParams, *miner11.ApplyRewardParams](rawParams, nil, false) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parseGeneric[*miner10.ApplyRewardParams, *miner10.ApplyRewardParams](rawParams, nil, false) - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return parseGeneric[*miner9.ApplyRewardParams, *miner9.ApplyRewardParams](rawParams, nil, false) - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): return parseGeneric[*miner8.ApplyRewardParams, *miner8.ApplyRewardParams](rawParams, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) @@ -280,21 +280,21 @@ func ApplyRewards(network string, height int64, rawParams []byte) (map[string]in func OnDeferredCronEvent(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parseGeneric[*miner15.DeferredCronEventParams, *miner15.DeferredCronEventParams](rawParams, nil, false) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parseGeneric[*miner14.DeferredCronEventParams, *miner14.DeferredCronEventParams](rawParams, nil, false) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parseGeneric[*miner13.DeferredCronEventParams, *miner13.DeferredCronEventParams](rawParams, nil, false) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parseGeneric[*miner12.DeferredCronEventParams, *miner12.DeferredCronEventParams](rawParams, nil, false) - case tools.V11.IsSupported(network, height): + case tools.V20.IsSupported(network, height): return parseGeneric[*miner11.DeferredCronEventParams, *miner11.DeferredCronEventParams](rawParams, nil, false) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parseGeneric[*miner10.DeferredCronEventParams, *miner10.DeferredCronEventParams](rawParams, nil, false) - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return parseGeneric[*miner9.DeferredCronEventParams, *miner9.DeferredCronEventParams](rawParams, nil, false) - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): return parseGeneric[*miner8.DeferredCronEventParams, *miner8.DeferredCronEventParams](rawParams, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) diff --git a/actors/miner/sector.go b/actors/miner/sector.go index 20287586..2e46261c 100644 --- a/actors/miner/sector.go +++ b/actors/miner/sector.go @@ -16,21 +16,21 @@ import ( func ExtendSectorExpiration2(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parseGeneric[*miner15.ExtendSectorExpiration2Params, *miner15.ExtendSectorExpiration2Params](rawParams, nil, false) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parseGeneric[*miner14.ExtendSectorExpiration2Params, *miner14.ExtendSectorExpiration2Params](rawParams, nil, false) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parseGeneric[*miner13.ExtendSectorExpiration2Params, *miner13.ExtendSectorExpiration2Params](rawParams, nil, false) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parseGeneric[*miner12.ExtendSectorExpiration2Params, *miner12.ExtendSectorExpiration2Params](rawParams, nil, false) - case tools.V11.IsSupported(network, height): + case tools.V19.IsSupported(network, height): return parseGeneric[*miner11.ExtendSectorExpiration2Params, *miner11.ExtendSectorExpiration2Params](rawParams, nil, false) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parseGeneric[*miner10.ExtendSectorExpiration2Params, *miner10.ExtendSectorExpiration2Params](rawParams, nil, false) - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return parseGeneric[*miner9.ExtendSectorExpiration2Params, *miner9.ExtendSectorExpiration2Params](rawParams, nil, false) - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): return nil, fmt.Errorf("not supported") } return nil, fmt.Errorf("unsupported height: %d", height) @@ -38,21 +38,21 @@ func ExtendSectorExpiration2(network string, height int64, rawParams []byte) (ma func PreCommitSector(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parseGeneric[*miner15.PreCommitSectorParams, *miner15.PreCommitSectorParams](rawParams, nil, false) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parseGeneric[*miner14.PreCommitSectorParams, *miner14.PreCommitSectorParams](rawParams, nil, false) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parseGeneric[*miner13.PreCommitSectorParams, *miner13.PreCommitSectorParams](rawParams, nil, false) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parseGeneric[*miner12.PreCommitSectorParams, *miner12.PreCommitSectorParams](rawParams, nil, false) - case tools.V11.IsSupported(network, height): + case tools.V19.IsSupported(network, height): return parseGeneric[*miner11.PreCommitSectorParams, *miner11.PreCommitSectorParams](rawParams, nil, false) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parseGeneric[*miner10.PreCommitSectorParams, *miner10.PreCommitSectorParams](rawParams, nil, false) - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return parseGeneric[*miner9.PreCommitSectorParams, *miner9.PreCommitSectorParams](rawParams, nil, false) - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): return parseGeneric[*miner8.PreCommitSectorParams, *miner8.PreCommitSectorParams](rawParams, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) @@ -60,21 +60,21 @@ func PreCommitSector(network string, height int64, rawParams []byte) (map[string func ProveCommitSector(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parseGeneric[*miner15.ProveCommitSectorParams, *miner15.ProveCommitSectorParams](rawParams, nil, false) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parseGeneric[*miner14.ProveCommitSectorParams, *miner14.ProveCommitSectorParams](rawParams, nil, false) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parseGeneric[*miner13.ProveCommitSectorParams, *miner13.ProveCommitSectorParams](rawParams, nil, false) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parseGeneric[*miner12.ProveCommitSectorParams, *miner12.ProveCommitSectorParams](rawParams, nil, false) - case tools.V11.IsSupported(network, height): + case tools.V19.IsSupported(network, height): return parseGeneric[*miner11.ProveCommitSectorParams, *miner11.ProveCommitSectorParams](rawParams, nil, false) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parseGeneric[*miner10.ProveCommitSectorParams, *miner10.ProveCommitSectorParams](rawParams, nil, false) - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return parseGeneric[*miner9.ProveCommitSectorParams, *miner9.ProveCommitSectorParams](rawParams, nil, false) - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): return parseGeneric[*miner8.ProveCommitSectorParams, *miner8.ProveCommitSectorParams](rawParams, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) @@ -82,21 +82,21 @@ func ProveCommitSector(network string, height int64, rawParams []byte) (map[stri func ProveCommitSectors3(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parseGeneric[*miner15.ProveCommitSectors3Params, *miner15.ProveCommitSectors3Return](rawParams, rawReturn, true) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parseGeneric[*miner14.ProveCommitSectors3Params, *miner14.ProveCommitSectors3Return](rawParams, rawReturn, true) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parseGeneric[*miner13.ProveCommitSectors3Params, *miner13.ProveCommitSectors3Return](rawParams, rawReturn, true) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return nil, fmt.Errorf("not supported") - case tools.V11.IsSupported(network, height): + case tools.V19.IsSupported(network, height): return nil, fmt.Errorf("not supported") - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return nil, fmt.Errorf("not supported") - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return nil, fmt.Errorf("not supported") - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): return nil, fmt.Errorf("not supported") } return nil, fmt.Errorf("unsupported height: %d", height) @@ -104,21 +104,21 @@ func ProveCommitSectors3(network string, height int64, rawParams, rawReturn []by func SubmitWindowedPoSt(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parseGeneric[*miner15.SubmitWindowedPoStParams, *miner15.SubmitWindowedPoStParams](rawParams, nil, false) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parseGeneric[*miner14.SubmitWindowedPoStParams, *miner14.SubmitWindowedPoStParams](rawParams, nil, false) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parseGeneric[*miner13.SubmitWindowedPoStParams, *miner13.SubmitWindowedPoStParams](rawParams, nil, false) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parseGeneric[*miner12.SubmitWindowedPoStParams, *miner12.SubmitWindowedPoStParams](rawParams, nil, false) - case tools.V11.IsSupported(network, height): + case tools.V19.IsSupported(network, height): return parseGeneric[*miner11.SubmitWindowedPoStParams, *miner11.SubmitWindowedPoStParams](rawParams, nil, false) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parseGeneric[*miner10.SubmitWindowedPoStParams, *miner10.SubmitWindowedPoStParams](rawParams, nil, false) - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return parseGeneric[*miner9.SubmitWindowedPoStParams, *miner9.SubmitWindowedPoStParams](rawParams, nil, false) - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): return parseGeneric[*miner8.SubmitWindowedPoStParams, *miner8.SubmitWindowedPoStParams](rawParams, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) @@ -126,21 +126,21 @@ func SubmitWindowedPoSt(network string, height int64, rawParams []byte) (map[str func ConfirmSectorProofsValid(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return nil, fmt.Errorf("not supported") - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return nil, fmt.Errorf("not supported") - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parseGeneric[*miner13.ConfirmSectorProofsParams, *miner13.ConfirmSectorProofsParams](rawParams, nil, false) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parseGeneric[*miner12.ConfirmSectorProofsParams, *miner12.ConfirmSectorProofsParams](rawParams, nil, false) - case tools.V11.IsSupported(network, height): + case tools.V19.IsSupported(network, height): return parseGeneric[*miner11.ConfirmSectorProofsParams, *miner11.ConfirmSectorProofsParams](rawParams, nil, false) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parseGeneric[*miner10.ConfirmSectorProofsParams, *miner10.ConfirmSectorProofsParams](rawParams, nil, false) - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return parseGeneric[*miner9.ConfirmSectorProofsParams, *miner9.ConfirmSectorProofsParams](rawParams, nil, false) - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): return parseGeneric[*miner8.ConfirmSectorProofsParams, *miner8.ConfirmSectorProofsParams](rawParams, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) @@ -148,21 +148,21 @@ func ConfirmSectorProofsValid(network string, height int64, rawParams []byte) (m func CheckSectorProven(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parseGeneric[*miner15.CheckSectorProvenParams, *miner15.CheckSectorProvenParams](rawParams, nil, false) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parseGeneric[*miner14.CheckSectorProvenParams, *miner14.CheckSectorProvenParams](rawParams, nil, false) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parseGeneric[*miner13.CheckSectorProvenParams, *miner13.CheckSectorProvenParams](rawParams, nil, false) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parseGeneric[*miner12.CheckSectorProvenParams, *miner12.CheckSectorProvenParams](rawParams, nil, false) - case tools.V11.IsSupported(network, height): + case tools.V19.IsSupported(network, height): return parseGeneric[*miner11.CheckSectorProvenParams, *miner11.CheckSectorProvenParams](rawParams, nil, false) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parseGeneric[*miner10.CheckSectorProvenParams, *miner10.CheckSectorProvenParams](rawParams, nil, false) - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return parseGeneric[*miner9.CheckSectorProvenParams, *miner9.CheckSectorProvenParams](rawParams, nil, false) - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): return parseGeneric[*miner8.CheckSectorProvenParams, *miner8.CheckSectorProvenParams](rawParams, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) @@ -170,21 +170,21 @@ func CheckSectorProven(network string, height int64, rawParams []byte) (map[stri func ExtendSectorExpiration(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parseGeneric[*miner15.ExtendSectorExpirationParams, *miner15.ExtendSectorExpirationParams](rawParams, nil, false) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parseGeneric[*miner14.ExtendSectorExpirationParams, *miner14.ExtendSectorExpirationParams](rawParams, nil, false) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parseGeneric[*miner13.ExtendSectorExpirationParams, *miner13.ExtendSectorExpirationParams](rawParams, nil, false) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parseGeneric[*miner12.ExtendSectorExpirationParams, *miner12.ExtendSectorExpirationParams](rawParams, nil, false) - case tools.V11.IsSupported(network, height): + case tools.V19.IsSupported(network, height): return parseGeneric[*miner11.ExtendSectorExpirationParams, *miner11.ExtendSectorExpirationParams](rawParams, nil, false) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parseGeneric[*miner10.ExtendSectorExpirationParams, *miner10.ExtendSectorExpirationParams](rawParams, nil, false) - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return parseGeneric[*miner9.ExtendSectorExpirationParams, *miner9.ExtendSectorExpirationParams](rawParams, nil, false) - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): return parseGeneric[*miner8.ExtendSectorExpirationParams, *miner8.ExtendSectorExpirationParams](rawParams, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) @@ -192,21 +192,21 @@ func ExtendSectorExpiration(network string, height int64, rawParams []byte) (map func CompactSectorNumbers(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parseGeneric[*miner15.CompactSectorNumbersParams, *miner15.CompactSectorNumbersParams](rawParams, nil, false) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parseGeneric[*miner14.CompactSectorNumbersParams, *miner14.CompactSectorNumbersParams](rawParams, nil, false) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parseGeneric[*miner13.CompactSectorNumbersParams, *miner13.CompactSectorNumbersParams](rawParams, nil, false) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parseGeneric[*miner12.CompactSectorNumbersParams, *miner12.CompactSectorNumbersParams](rawParams, nil, false) - case tools.V11.IsSupported(network, height): + case tools.V19.IsSupported(network, height): return parseGeneric[*miner11.CompactSectorNumbersParams, *miner11.CompactSectorNumbersParams](rawParams, nil, false) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parseGeneric[*miner10.CompactSectorNumbersParams, *miner10.CompactSectorNumbersParams](rawParams, nil, false) - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return parseGeneric[*miner9.CompactSectorNumbersParams, *miner9.CompactSectorNumbersParams](rawParams, nil, false) - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): return parseGeneric[*miner8.CompactSectorNumbersParams, *miner8.CompactSectorNumbersParams](rawParams, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) @@ -214,21 +214,21 @@ func CompactSectorNumbers(network string, height int64, rawParams []byte) (map[s func CompactPartitions(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parseGeneric[*miner15.CompactPartitionsParams, *miner15.CompactPartitionsParams](rawParams, nil, false) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parseGeneric[*miner14.CompactPartitionsParams, *miner14.CompactPartitionsParams](rawParams, nil, false) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parseGeneric[*miner13.CompactPartitionsParams, *miner13.CompactPartitionsParams](rawParams, nil, false) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parseGeneric[*miner12.CompactPartitionsParams, *miner12.CompactPartitionsParams](rawParams, nil, false) - case tools.V11.IsSupported(network, height): + case tools.V19.IsSupported(network, height): return parseGeneric[*miner11.CompactPartitionsParams, *miner11.CompactPartitionsParams](rawParams, nil, false) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parseGeneric[*miner10.CompactPartitionsParams, *miner10.CompactPartitionsParams](rawParams, nil, false) - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return parseGeneric[*miner9.CompactPartitionsParams, *miner9.CompactPartitionsParams](rawParams, nil, false) - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): return parseGeneric[*miner8.CompactPartitionsParams, *miner8.CompactPartitionsParams](rawParams, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) @@ -236,21 +236,21 @@ func CompactPartitions(network string, height int64, rawParams []byte) (map[stri func PreCommitSectorBatch(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parseGeneric[*miner15.PreCommitSectorBatchParams, *miner15.PreCommitSectorBatchParams](rawParams, nil, false) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parseGeneric[*miner14.PreCommitSectorBatchParams, *miner14.PreCommitSectorBatchParams](rawParams, nil, false) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parseGeneric[*miner13.PreCommitSectorBatchParams, *miner13.PreCommitSectorBatchParams](rawParams, nil, false) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parseGeneric[*miner12.PreCommitSectorBatchParams, *miner12.PreCommitSectorBatchParams](rawParams, nil, false) - case tools.V11.IsSupported(network, height): + case tools.V19.IsSupported(network, height): return parseGeneric[*miner11.PreCommitSectorBatchParams, *miner11.PreCommitSectorBatchParams](rawParams, nil, false) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parseGeneric[*miner10.PreCommitSectorBatchParams, *miner10.PreCommitSectorBatchParams](rawParams, nil, false) - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return parseGeneric[*miner9.PreCommitSectorBatchParams, *miner9.PreCommitSectorBatchParams](rawParams, nil, false) - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): return parseGeneric[*miner8.PreCommitSectorBatchParams, *miner8.PreCommitSectorBatchParams](rawParams, nil, false) } return nil, fmt.Errorf("unsupported height: %d", height) diff --git a/actors/multisig/multisig.go b/actors/multisig/multisig.go index 01cee239..8b2ac703 100644 --- a/actors/multisig/multisig.go +++ b/actors/multisig/multisig.go @@ -19,21 +19,21 @@ import ( func MsigConstructor(network string, height int64, raw []byte) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): return parse[*multisig8.ConstructorParams, []byte](raw, cborUnmarshaller[*multisig8.ConstructorParams]) - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return parse[*multisig9.ConstructorParams, []byte](raw, cborUnmarshaller[*multisig9.ConstructorParams]) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parse[*multisig10.ConstructorParams, []byte](raw, cborUnmarshaller[*multisig10.ConstructorParams]) - case tools.V11.IsSupported(network, height): + case tools.V20.IsSupported(network, height): return parse[*multisig11.ConstructorParams, []byte](raw, cborUnmarshaller[*multisig11.ConstructorParams]) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parse[*multisig12.ConstructorParams, []byte](raw, cborUnmarshaller[*multisig12.ConstructorParams]) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parse[*multisig13.ConstructorParams, []byte](raw, cborUnmarshaller[*multisig13.ConstructorParams]) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parse[*multisig14.ConstructorParams, []byte](raw, cborUnmarshaller[*multisig14.ConstructorParams]) - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parse[*multisig15.ConstructorParams, []byte](raw, cborUnmarshaller[*multisig15.ConstructorParams]) } return map[string]interface{}{}, nil @@ -41,21 +41,21 @@ func MsigConstructor(network string, height int64, raw []byte) (map[string]inter func MsigParams(network string, msg *parser.LotusMessage, height int64, key filTypes.TipSetKey, parser ParseFn) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): return parseWithMsigParser[*multisig8.ConstructorParams, *multisig8.ConstructorParams](msg, height, key, parser, nil, jsonUnmarshaller[*multisig8.ConstructorParams], false) - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return parseWithMsigParser[*multisig9.ConstructorParams, *multisig9.ConstructorParams](msg, height, key, parser, nil, jsonUnmarshaller[*multisig9.ConstructorParams], false) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parseWithMsigParser[*multisig10.ConstructorParams, *multisig10.ConstructorParams](msg, height, key, parser, nil, jsonUnmarshaller[*multisig10.ConstructorParams], false) - case tools.V11.IsSupported(network, height): + case tools.V20.IsSupported(network, height): return parseWithMsigParser[*multisig11.ConstructorParams, *multisig11.ConstructorParams](msg, height, key, parser, nil, jsonUnmarshaller[*multisig11.ConstructorParams], false) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parseWithMsigParser[*multisig12.ConstructorParams, *multisig12.ConstructorParams](msg, height, key, parser, nil, jsonUnmarshaller[*multisig12.ConstructorParams], false) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parseWithMsigParser[*multisig13.ConstructorParams, *multisig13.ConstructorParams](msg, height, key, parser, nil, jsonUnmarshaller[*multisig13.ConstructorParams], false) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parseWithMsigParser[*multisig14.ConstructorParams, *multisig14.ConstructorParams](msg, height, key, parser, nil, jsonUnmarshaller[*multisig14.ConstructorParams], false) - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parseWithMsigParser[*multisig15.ConstructorParams, *multisig15.ConstructorParams](msg, height, key, parser, nil, jsonUnmarshaller[*multisig15.ConstructorParams], false) } return map[string]interface{}{}, nil @@ -63,21 +63,21 @@ func MsigParams(network string, msg *parser.LotusMessage, height int64, key filT func Approve(network string, msg *parser.LotusMessage, height int64, key filTypes.TipSetKey, rawReturn []byte, parser ParseFn) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): return parseWithMsigParser[*multisig8.ApproveReturn, *multisig8.ApproveReturn](msg, height, key, parser, rawReturn, cborUnmarshaller[*multisig8.ApproveReturn], true) - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return parseWithMsigParser[*multisig9.ApproveReturn, *multisig9.ApproveReturn](msg, height, key, parser, rawReturn, cborUnmarshaller[*multisig9.ApproveReturn], true) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parseWithMsigParser[*multisig10.ApproveReturn, *multisig10.ApproveReturn](msg, height, key, parser, rawReturn, cborUnmarshaller[*multisig10.ApproveReturn], true) - case tools.V11.IsSupported(network, height): + case tools.V20.IsSupported(network, height): return parseWithMsigParser[*multisig11.ApproveReturn, *multisig11.ApproveReturn](msg, height, key, parser, rawReturn, cborUnmarshaller[*multisig11.ApproveReturn], true) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parseWithMsigParser[*multisig12.ApproveReturn, *multisig12.ApproveReturn](msg, height, key, parser, rawReturn, cborUnmarshaller[*multisig12.ApproveReturn], true) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parseWithMsigParser[*multisig13.ApproveReturn, *multisig13.ApproveReturn](msg, height, key, parser, rawReturn, cborUnmarshaller[*multisig13.ApproveReturn], true) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parseWithMsigParser[*multisig14.ApproveReturn, *multisig14.ApproveReturn](msg, height, key, parser, rawReturn, cborUnmarshaller[*multisig14.ApproveReturn], true) - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parseWithMsigParser[*multisig15.ApproveReturn, *multisig15.ApproveReturn](msg, height, key, parser, rawReturn, cborUnmarshaller[*multisig15.ApproveReturn], true) } return map[string]interface{}{}, nil @@ -85,21 +85,21 @@ func Approve(network string, msg *parser.LotusMessage, height int64, key filType func Cancel(network string, msg *parser.LotusMessage, height int64, key filTypes.TipSetKey, rawReturn []byte, parser ParseFn) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): return parseWithMsigParser[metadataWithCbor, metadataWithCbor](msg, height, key, parser, rawReturn, noopUnmarshaller[metadataWithCbor], false) - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return parseWithMsigParser[metadataWithCbor, metadataWithCbor](msg, height, key, parser, rawReturn, noopUnmarshaller[metadataWithCbor], false) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parseWithMsigParser[metadataWithCbor, metadataWithCbor](msg, height, key, parser, rawReturn, noopUnmarshaller[metadataWithCbor], false) - case tools.V11.IsSupported(network, height): + case tools.V20.IsSupported(network, height): return parseWithMsigParser[metadataWithCbor, metadataWithCbor](msg, height, key, parser, rawReturn, noopUnmarshaller[metadataWithCbor], false) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parseWithMsigParser[metadataWithCbor, metadataWithCbor](msg, height, key, parser, rawReturn, noopUnmarshaller[metadataWithCbor], false) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parseWithMsigParser[metadataWithCbor, metadataWithCbor](msg, height, key, parser, rawReturn, noopUnmarshaller[metadataWithCbor], false) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parseWithMsigParser[metadataWithCbor, metadataWithCbor](msg, height, key, parser, rawReturn, noopUnmarshaller[metadataWithCbor], false) - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parseWithMsigParser[metadataWithCbor, metadataWithCbor](msg, height, key, parser, rawReturn, noopUnmarshaller[metadataWithCbor], false) } return map[string]interface{}{}, nil @@ -107,21 +107,21 @@ func Cancel(network string, msg *parser.LotusMessage, height int64, key filTypes func RemoveSigner(network string, msg *parser.LotusMessage, height int64, key filTypes.TipSetKey, rawReturn []byte, parser ParseFn) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): return parseWithMsigParser[metadataWithCbor, metadataWithCbor](msg, height, key, parser, rawReturn, noopUnmarshaller[metadataWithCbor], false) - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return parseWithMsigParser[metadataWithCbor, metadataWithCbor](msg, height, key, parser, rawReturn, noopUnmarshaller[metadataWithCbor], false) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parseWithMsigParser[metadataWithCbor, metadataWithCbor](msg, height, key, parser, rawReturn, noopUnmarshaller[metadataWithCbor], false) - case tools.V11.IsSupported(network, height): + case tools.V20.IsSupported(network, height): return parseWithMsigParser[metadataWithCbor, metadataWithCbor](msg, height, key, parser, rawReturn, noopUnmarshaller[metadataWithCbor], false) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parseWithMsigParser[metadataWithCbor, metadataWithCbor](msg, height, key, parser, rawReturn, noopUnmarshaller[metadataWithCbor], false) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parseWithMsigParser[metadataWithCbor, metadataWithCbor](msg, height, key, parser, rawReturn, noopUnmarshaller[metadataWithCbor], false) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parseWithMsigParser[metadataWithCbor, metadataWithCbor](msg, height, key, parser, rawReturn, noopUnmarshaller[metadataWithCbor], false) - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parseWithMsigParser[metadataWithCbor, metadataWithCbor](msg, height, key, parser, rawReturn, noopUnmarshaller[metadataWithCbor], false) } return map[string]interface{}{}, nil @@ -129,21 +129,21 @@ func RemoveSigner(network string, msg *parser.LotusMessage, height int64, key fi func ChangeNumApprovalsThreshold(network string, msg *parser.LotusMessage, height int64, key filTypes.TipSetKey, rawReturn []byte, parser ParseFn) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): return parse[*multisig8.ChangeNumApprovalsThresholdParams, []byte](rawReturn, cborUnmarshaller[*multisig8.ChangeNumApprovalsThresholdParams]) - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return parse[*multisig9.ChangeNumApprovalsThresholdParams, []byte](rawReturn, cborUnmarshaller[*multisig9.ChangeNumApprovalsThresholdParams]) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parse[*multisig10.ChangeNumApprovalsThresholdParams, []byte](rawReturn, cborUnmarshaller[*multisig10.ChangeNumApprovalsThresholdParams]) - case tools.V11.IsSupported(network, height): + case tools.V20.IsSupported(network, height): return parse[*multisig11.ChangeNumApprovalsThresholdParams, []byte](rawReturn, cborUnmarshaller[*multisig11.ChangeNumApprovalsThresholdParams]) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parse[*multisig12.ChangeNumApprovalsThresholdParams, []byte](rawReturn, cborUnmarshaller[*multisig12.ChangeNumApprovalsThresholdParams]) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parse[*multisig13.ChangeNumApprovalsThresholdParams, []byte](rawReturn, cborUnmarshaller[*multisig13.ChangeNumApprovalsThresholdParams]) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parse[*multisig14.ChangeNumApprovalsThresholdParams, []byte](rawReturn, cborUnmarshaller[*multisig14.ChangeNumApprovalsThresholdParams]) - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parse[*multisig15.ChangeNumApprovalsThresholdParams, []byte](rawReturn, cborUnmarshaller[*multisig15.ChangeNumApprovalsThresholdParams]) } return map[string]interface{}{}, nil @@ -151,21 +151,21 @@ func ChangeNumApprovalsThreshold(network string, msg *parser.LotusMessage, heigh func LockBalance(network string, msg *parser.LotusMessage, height int64, key filTypes.TipSetKey, rawReturn []byte, parser ParseFn) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): return parse[*multisig8.LockBalanceParams, []byte](rawReturn, cborUnmarshaller[*multisig8.LockBalanceParams]) - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return parse[*multisig9.LockBalanceParams, []byte](rawReturn, cborUnmarshaller[*multisig9.LockBalanceParams]) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parse[*multisig10.LockBalanceParams, []byte](rawReturn, cborUnmarshaller[*multisig10.LockBalanceParams]) - case tools.V11.IsSupported(network, height): + case tools.V20.IsSupported(network, height): return parse[*multisig11.LockBalanceParams, []byte](rawReturn, cborUnmarshaller[*multisig11.LockBalanceParams]) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parse[*multisig12.LockBalanceParams, []byte](rawReturn, cborUnmarshaller[*multisig12.LockBalanceParams]) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parse[*multisig13.LockBalanceParams, []byte](rawReturn, cborUnmarshaller[*multisig13.LockBalanceParams]) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parse[*multisig14.LockBalanceParams, []byte](rawReturn, cborUnmarshaller[*multisig14.LockBalanceParams]) - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parse[*multisig15.LockBalanceParams, []byte](rawReturn, cborUnmarshaller[*multisig15.LockBalanceParams]) } return map[string]interface{}{}, nil @@ -173,21 +173,21 @@ func LockBalance(network string, msg *parser.LotusMessage, height int64, key fil func UniversalReceiverHook(network string, msg *parser.LotusMessage, height int64, key filTypes.TipSetKey, rawReturn []byte, parser ParseFn) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): return parse[*abi.CborBytesTransparent, []byte](rawReturn, cborUnmarshaller[*abi.CborBytesTransparent]) - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return parse[*abi.CborBytesTransparent, []byte](rawReturn, cborUnmarshaller[*abi.CborBytesTransparent]) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parse[*abi.CborBytesTransparent, []byte](rawReturn, cborUnmarshaller[*abi.CborBytesTransparent]) - case tools.V11.IsSupported(network, height): + case tools.V20.IsSupported(network, height): return parse[*abi.CborBytesTransparent, []byte](rawReturn, cborUnmarshaller[*abi.CborBytesTransparent]) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parse[*abi.CborBytesTransparent, []byte](rawReturn, cborUnmarshaller[*abi.CborBytesTransparent]) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parse[*abi.CborBytesTransparent, []byte](rawReturn, cborUnmarshaller[*abi.CborBytesTransparent]) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parse[*abi.CborBytesTransparent, []byte](rawReturn, cborUnmarshaller[*abi.CborBytesTransparent]) - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parse[*abi.CborBytesTransparent, []byte](rawReturn, cborUnmarshaller[*abi.CborBytesTransparent]) } return map[string]interface{}{}, nil diff --git a/actors/multisig/values.go b/actors/multisig/values.go index ce31eada..412d46a4 100644 --- a/actors/multisig/values.go +++ b/actors/multisig/values.go @@ -17,21 +17,21 @@ import ( func ChangeOwnerAddressValue(network string, height int64, txMetadata string) (interface{}, error) { switch { - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): return parse[*ChangeOwnerAddressParams, string](txMetadata, jsonUnmarshaller[*ChangeOwnerAddressParams]) - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return parse[*ChangeOwnerAddressParams, string](txMetadata, jsonUnmarshaller[*ChangeOwnerAddressParams]) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parse[*ChangeOwnerAddressParams, string](txMetadata, jsonUnmarshaller[*ChangeOwnerAddressParams]) - case tools.V11.IsSupported(network, height): + case tools.V19.IsSupported(network, height): return parse[*ChangeOwnerAddressParams, string](txMetadata, jsonUnmarshaller[*ChangeOwnerAddressParams]) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parse[*ChangeOwnerAddressParams, string](txMetadata, jsonUnmarshaller[*ChangeOwnerAddressParams]) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parse[*ChangeOwnerAddressParams, string](txMetadata, jsonUnmarshaller[*ChangeOwnerAddressParams]) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parse[*ChangeOwnerAddressParams, string](txMetadata, jsonUnmarshaller[*ChangeOwnerAddressParams]) - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parse[*ChangeOwnerAddressParams, string](txMetadata, jsonUnmarshaller[*ChangeOwnerAddressParams]) } return nil, nil @@ -39,21 +39,21 @@ func ChangeOwnerAddressValue(network string, height int64, txMetadata string) (i func ParseWithdrawBalanceValue(network string, height int64, txMetadata string) (interface{}, error) { switch { - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): return parse[*miner11.WithdrawBalanceParams, string](txMetadata, jsonUnmarshaller[*miner11.WithdrawBalanceParams]) - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return parse[*miner11.WithdrawBalanceParams, string](txMetadata, jsonUnmarshaller[*miner11.WithdrawBalanceParams]) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parse[*miner11.WithdrawBalanceParams, string](txMetadata, jsonUnmarshaller[*miner11.WithdrawBalanceParams]) - case tools.V11.IsSupported(network, height): + case tools.V19.IsSupported(network, height): return parse[*miner11.WithdrawBalanceParams, string](txMetadata, jsonUnmarshaller[*miner11.WithdrawBalanceParams]) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parse[*miner11.WithdrawBalanceParams, string](txMetadata, jsonUnmarshaller[*miner11.WithdrawBalanceParams]) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parse[*miner11.WithdrawBalanceParams, string](txMetadata, jsonUnmarshaller[*miner11.WithdrawBalanceParams]) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parse[*miner11.WithdrawBalanceParams, string](txMetadata, jsonUnmarshaller[*miner11.WithdrawBalanceParams]) - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parse[*miner11.WithdrawBalanceParams, string](txMetadata, jsonUnmarshaller[*miner11.WithdrawBalanceParams]) } return nil, nil @@ -61,21 +61,21 @@ func ParseWithdrawBalanceValue(network string, height int64, txMetadata string) func ParseInvokeContractValue(network string, height int64, txMetadata string) (interface{}, error) { switch { - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): return parse[*InvokeContractParams, string](txMetadata, jsonUnmarshaller[*InvokeContractParams]) - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return parse[*InvokeContractParams, string](txMetadata, jsonUnmarshaller[*InvokeContractParams]) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parse[*InvokeContractParams, string](txMetadata, jsonUnmarshaller[*InvokeContractParams]) - case tools.V11.IsSupported(network, height): + case tools.V19.IsSupported(network, height): return parse[*InvokeContractParams, string](txMetadata, jsonUnmarshaller[*InvokeContractParams]) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parse[*InvokeContractParams, string](txMetadata, jsonUnmarshaller[*InvokeContractParams]) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parse[*InvokeContractParams, string](txMetadata, jsonUnmarshaller[*InvokeContractParams]) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parse[*InvokeContractParams, string](txMetadata, jsonUnmarshaller[*InvokeContractParams]) - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parse[*InvokeContractParams, string](txMetadata, jsonUnmarshaller[*InvokeContractParams]) } return nil, nil @@ -83,21 +83,21 @@ func ParseInvokeContractValue(network string, height int64, txMetadata string) ( func ParseAddSignerValue(network string, height int64, txMetadata string) (interface{}, error) { switch { - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): return parse[*multisig11.AddSignerParams, string](txMetadata, jsonUnmarshaller[*multisig11.AddSignerParams]) - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return parse[*multisig9.AddSignerParams, string](txMetadata, jsonUnmarshaller[*multisig9.AddSignerParams]) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parse[*multisig10.AddSignerParams, string](txMetadata, jsonUnmarshaller[*multisig10.AddSignerParams]) - case tools.V11.IsSupported(network, height): + case tools.V19.IsSupported(network, height): return parse[*multisig11.AddSignerParams, string](txMetadata, jsonUnmarshaller[*multisig11.AddSignerParams]) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parse[*multisig12.AddSignerParams, string](txMetadata, jsonUnmarshaller[*multisig12.AddSignerParams]) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parse[*multisig13.AddSignerParams, string](txMetadata, jsonUnmarshaller[*multisig13.AddSignerParams]) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parse[*multisig14.AddSignerParams, string](txMetadata, jsonUnmarshaller[*multisig14.AddSignerParams]) - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parse[*multisig15.AddSignerParams, string](txMetadata, jsonUnmarshaller[*multisig15.AddSignerParams]) } return nil, nil @@ -105,49 +105,49 @@ func ParseAddSignerValue(network string, height int64, txMetadata string) (inter func ParseApproveValue(network string, height int64, txMetadata string) (interface{}, error) { switch { - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): if data, err := parse[metadataWithCbor, string](txMetadata, jsonUnmarshaller[metadataWithCbor]); err != nil { return nil, err } else { return getApproveReturn(network, height, data) } - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): if data, err := parse[metadataWithCbor, string](txMetadata, jsonUnmarshaller[metadataWithCbor]); err != nil { return nil, err } else { return getApproveReturn(network, height, data) } - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): if data, err := parse[metadataWithCbor, string](txMetadata, jsonUnmarshaller[metadataWithCbor]); err != nil { return nil, err } else { return getApproveReturn(network, height, data) } - case tools.V11.IsSupported(network, height): + case tools.V19.IsSupported(network, height): if data, err := parse[metadataWithCbor, string](txMetadata, jsonUnmarshaller[metadataWithCbor]); err != nil { return nil, err } else { return getApproveReturn(network, height, data) } - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): if data, err := parse[metadataWithCbor, string](txMetadata, jsonUnmarshaller[metadataWithCbor]); err != nil { return nil, err } else { return getApproveReturn(network, height, data) } - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): if data, err := parse[metadataWithCbor, string](txMetadata, jsonUnmarshaller[metadataWithCbor]); err != nil { return nil, err } else { return getApproveReturn(network, height, data) } - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): if data, err := parse[metadataWithCbor, string](txMetadata, jsonUnmarshaller[metadataWithCbor]); err != nil { return nil, err } else { return getApproveReturn(network, height, data) } - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): if data, err := parse[metadataWithCbor, string](txMetadata, jsonUnmarshaller[metadataWithCbor]); err != nil { return nil, err } else { @@ -159,49 +159,49 @@ func ParseApproveValue(network string, height int64, txMetadata string) (interfa func ParseCancelValue(network string, height int64, txMetadata string) (interface{}, error) { switch { - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): if data, err := parse[metadataWithCbor, string](txMetadata, jsonUnmarshaller[metadataWithCbor]); err != nil { return nil, err } else { return getCancelReturn(data) } - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): if data, err := parse[metadataWithCbor, string](txMetadata, jsonUnmarshaller[metadataWithCbor]); err != nil { return nil, err } else { return getCancelReturn(data) } - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): if data, err := parse[metadataWithCbor, string](txMetadata, jsonUnmarshaller[metadataWithCbor]); err != nil { return nil, err } else { return getCancelReturn(data) } - case tools.V11.IsSupported(network, height): + case tools.V19.IsSupported(network, height): if data, err := parse[metadataWithCbor, string](txMetadata, jsonUnmarshaller[metadataWithCbor]); err != nil { return nil, err } else { return getCancelReturn(data) } - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): if data, err := parse[metadataWithCbor, string](txMetadata, jsonUnmarshaller[metadataWithCbor]); err != nil { return nil, err } else { return getCancelReturn(data) } - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): if data, err := parse[metadataWithCbor, string](txMetadata, jsonUnmarshaller[metadataWithCbor]); err != nil { return nil, err } else { return getCancelReturn(data) } - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): if data, err := parse[metadataWithCbor, string](txMetadata, jsonUnmarshaller[metadataWithCbor]); err != nil { return nil, err } else { return getCancelReturn(data) } - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): if data, err := parse[metadataWithCbor, string](txMetadata, jsonUnmarshaller[metadataWithCbor]); err != nil { return nil, err } else { @@ -213,21 +213,21 @@ func ParseCancelValue(network string, height int64, txMetadata string) (interfac func ChangeNumApprovalsThresholdValue(network string, height int64, txMetadata string) (interface{}, error) { switch { - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): return parse[*multisig8.ChangeNumApprovalsThresholdParams, string](txMetadata, jsonUnmarshaller[*multisig8.ChangeNumApprovalsThresholdParams]) - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return parse[*multisig9.ChangeNumApprovalsThresholdParams, string](txMetadata, jsonUnmarshaller[*multisig9.ChangeNumApprovalsThresholdParams]) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parse[*multisig10.ChangeNumApprovalsThresholdParams, string](txMetadata, jsonUnmarshaller[*multisig10.ChangeNumApprovalsThresholdParams]) - case tools.V11.IsSupported(network, height): + case tools.V19.IsSupported(network, height): return parse[*multisig11.ChangeNumApprovalsThresholdParams, string](txMetadata, jsonUnmarshaller[*multisig11.ChangeNumApprovalsThresholdParams]) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parse[*multisig12.ChangeNumApprovalsThresholdParams, string](txMetadata, jsonUnmarshaller[*multisig12.ChangeNumApprovalsThresholdParams]) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parse[*multisig13.ChangeNumApprovalsThresholdParams, string](txMetadata, jsonUnmarshaller[*multisig13.ChangeNumApprovalsThresholdParams]) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parse[*multisig14.ChangeNumApprovalsThresholdParams, string](txMetadata, jsonUnmarshaller[*multisig14.ChangeNumApprovalsThresholdParams]) - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parse[*multisig15.ChangeNumApprovalsThresholdParams, string](txMetadata, jsonUnmarshaller[*multisig15.ChangeNumApprovalsThresholdParams]) } return nil, nil @@ -235,49 +235,49 @@ func ChangeNumApprovalsThresholdValue(network string, height int64, txMetadata s func ParseConstructorValue(network string, height int64, txMetadata string) (interface{}, error) { switch { - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): if data, err := parse[*multisig8.ConstructorParams, string](txMetadata, jsonUnmarshaller[*multisig8.ConstructorParams]); err != nil { return nil, err } else { return getValue[*multisig8.ConstructorParams](height, data) } - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): if data, err := parse[*multisig9.ConstructorParams, string](txMetadata, jsonUnmarshaller[*multisig9.ConstructorParams]); err != nil { return nil, err } else { return getValue[*multisig9.ConstructorParams](height, data) } - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): if data, err := parse[*multisig10.ConstructorParams, string](txMetadata, jsonUnmarshaller[*multisig10.ConstructorParams]); err != nil { return nil, err } else { return getValue[*multisig10.ConstructorParams](height, data) } - case tools.V11.IsSupported(network, height): + case tools.V19.IsSupported(network, height): if data, err := parse[*multisig11.ConstructorParams, string](txMetadata, jsonUnmarshaller[*multisig11.ConstructorParams]); err != nil { return nil, err } else { return getValue[*multisig11.ConstructorParams](height, data) } - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): if data, err := parse[*multisig12.ConstructorParams, string](txMetadata, jsonUnmarshaller[*multisig12.ConstructorParams]); err != nil { return nil, err } else { return getValue[*multisig12.ConstructorParams](height, data) } - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): if data, err := parse[*multisig13.ConstructorParams, string](txMetadata, jsonUnmarshaller[*multisig13.ConstructorParams]); err != nil { return nil, err } else { return getValue[*multisig13.ConstructorParams](height, data) } - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): if data, err := parse[*multisig14.ConstructorParams, string](txMetadata, jsonUnmarshaller[*multisig14.ConstructorParams]); err != nil { return nil, err } else { return getValue[*multisig14.ConstructorParams](height, data) } - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): if data, err := parse[*multisig15.ConstructorParams, string](txMetadata, jsonUnmarshaller[*multisig15.ConstructorParams]); err != nil { return nil, err } else { @@ -289,49 +289,49 @@ func ParseConstructorValue(network string, height int64, txMetadata string) (int func ParseLockBalanceValue(network string, height int64, txMetadata string) (interface{}, error) { switch { - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): if data, err := parse[*multisig8.LockBalanceParams, string](txMetadata, jsonUnmarshaller[*multisig8.LockBalanceParams]); err != nil { return nil, err } else { return getValue[*multisig8.LockBalanceParams](height, data) } - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): if data, err := parse[*multisig9.LockBalanceParams, string](txMetadata, jsonUnmarshaller[*multisig9.LockBalanceParams]); err != nil { return nil, err } else { return getValue[*multisig9.LockBalanceParams](height, data) } - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): if data, err := parse[*multisig10.LockBalanceParams, string](txMetadata, jsonUnmarshaller[*multisig10.LockBalanceParams]); err != nil { return nil, err } else { return getValue[*multisig10.LockBalanceParams](height, data) } - case tools.V11.IsSupported(network, height): + case tools.V19.IsSupported(network, height): if data, err := parse[*multisig11.LockBalanceParams, string](txMetadata, jsonUnmarshaller[*multisig11.LockBalanceParams]); err != nil { return nil, err } else { return getValue[*multisig11.LockBalanceParams](height, data) } - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): if data, err := parse[*multisig12.LockBalanceParams, string](txMetadata, jsonUnmarshaller[*multisig12.LockBalanceParams]); err != nil { return nil, err } else { return getValue[*multisig12.LockBalanceParams](height, data) } - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): if data, err := parse[*multisig13.LockBalanceParams, string](txMetadata, jsonUnmarshaller[*multisig13.LockBalanceParams]); err != nil { return nil, err } else { return getValue[*multisig13.LockBalanceParams](height, data) } - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): if data, err := parse[*multisig14.LockBalanceParams, string](txMetadata, jsonUnmarshaller[*multisig14.LockBalanceParams]); err != nil { return nil, err } else { return getValue[*multisig14.LockBalanceParams](height, data) } - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): if data, err := parse[*multisig15.LockBalanceParams, string](txMetadata, jsonUnmarshaller[*multisig15.LockBalanceParams]); err != nil { return nil, err } else { @@ -343,49 +343,49 @@ func ParseLockBalanceValue(network string, height int64, txMetadata string) (int func ParseRemoveSignerValue(network string, height int64, txMetadata string) (interface{}, error) { switch { - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): if data, err := parse[*multisig8.RemoveSignerParams, string](txMetadata, jsonUnmarshaller[*multisig8.RemoveSignerParams]); err != nil { return nil, err } else { return getValue[*multisig8.RemoveSignerParams](height, data) } - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): if data, err := parse[*multisig9.RemoveSignerParams, string](txMetadata, jsonUnmarshaller[*multisig9.RemoveSignerParams]); err != nil { return nil, err } else { return getValue[*multisig9.RemoveSignerParams](height, data) } - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): if data, err := parse[*multisig10.RemoveSignerParams, string](txMetadata, jsonUnmarshaller[*multisig10.RemoveSignerParams]); err != nil { return nil, err } else { return getValue[*multisig10.RemoveSignerParams](height, data) } - case tools.V11.IsSupported(network, height): + case tools.V19.IsSupported(network, height): if data, err := parse[*multisig11.RemoveSignerParams, string](txMetadata, jsonUnmarshaller[*multisig11.RemoveSignerParams]); err != nil { return nil, err } else { return getValue[*multisig11.RemoveSignerParams](height, data) } - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): if data, err := parse[*multisig12.RemoveSignerParams, string](txMetadata, jsonUnmarshaller[*multisig12.RemoveSignerParams]); err != nil { return nil, err } else { return getValue[*multisig12.RemoveSignerParams](height, data) } - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): if data, err := parse[*multisig13.RemoveSignerParams, string](txMetadata, jsonUnmarshaller[*multisig13.RemoveSignerParams]); err != nil { return nil, err } else { return getValue[*multisig13.RemoveSignerParams](height, data) } - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): if data, err := parse[*multisig14.RemoveSignerParams, string](txMetadata, jsonUnmarshaller[*multisig14.RemoveSignerParams]); err != nil { return nil, err } else { return getValue[*multisig14.RemoveSignerParams](height, data) } - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): if data, err := parse[*multisig15.RemoveSignerParams, string](txMetadata, jsonUnmarshaller[*multisig15.RemoveSignerParams]); err != nil { return nil, err } else { @@ -397,21 +397,21 @@ func ParseRemoveSignerValue(network string, height int64, txMetadata string) (in func ParseSendValue(network string, height int64, txMetadata string) (interface{}, error) { switch { - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): return parse[*SendValue, string](txMetadata, jsonUnmarshaller[*SendValue]) - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return parse[*SendValue, string](txMetadata, jsonUnmarshaller[*SendValue]) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parse[*SendValue, string](txMetadata, jsonUnmarshaller[*SendValue]) - case tools.V11.IsSupported(network, height): + case tools.V19.IsSupported(network, height): return parse[*SendValue, string](txMetadata, jsonUnmarshaller[*SendValue]) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parse[*SendValue, string](txMetadata, jsonUnmarshaller[*SendValue]) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parse[*SendValue, string](txMetadata, jsonUnmarshaller[*SendValue]) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parse[*SendValue, string](txMetadata, jsonUnmarshaller[*SendValue]) - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parse[*SendValue, string](txMetadata, jsonUnmarshaller[*SendValue]) } return nil, nil @@ -419,21 +419,21 @@ func ParseSendValue(network string, height int64, txMetadata string) (interface{ func ParseSwapSignerValue(network string, height int64, txMetadata string) (interface{}, error) { switch { - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): return parse[*multisig8.SwapSignerParams, string](txMetadata, jsonUnmarshaller[*multisig8.SwapSignerParams]) - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return parse[*multisig9.SwapSignerParams, string](txMetadata, jsonUnmarshaller[*multisig9.SwapSignerParams]) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parse[*multisig10.SwapSignerParams, string](txMetadata, jsonUnmarshaller[*multisig10.SwapSignerParams]) - case tools.V11.IsSupported(network, height): + case tools.V19.IsSupported(network, height): return parse[*multisig11.SwapSignerParams, string](txMetadata, jsonUnmarshaller[*multisig11.SwapSignerParams]) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parse[*multisig12.SwapSignerParams, string](txMetadata, jsonUnmarshaller[*multisig12.SwapSignerParams]) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parse[*multisig13.SwapSignerParams, string](txMetadata, jsonUnmarshaller[*multisig13.SwapSignerParams]) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parse[*multisig14.SwapSignerParams, string](txMetadata, jsonUnmarshaller[*multisig14.SwapSignerParams]) - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parse[*multisig15.SwapSignerParams, string](txMetadata, jsonUnmarshaller[*multisig15.SwapSignerParams]) } return nil, nil diff --git a/actors/multisig/verifier.go b/actors/multisig/verifier.go index a7c2a442..4bb7d67d 100644 --- a/actors/multisig/verifier.go +++ b/actors/multisig/verifier.go @@ -14,21 +14,21 @@ import ( func AddVerifierValue(network string, height int64, txMetadata string) (interface{}, error) { switch { - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): return parse[*verifreg8.AddVerifierParams, string](txMetadata, jsonUnmarshaller[*verifreg8.AddVerifierParams]) - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return parse[*verifreg9.AddVerifierParams, string](txMetadata, jsonUnmarshaller[*verifreg9.AddVerifierParams]) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parse[*verifreg10.AddVerifierParams, string](txMetadata, jsonUnmarshaller[*verifreg10.AddVerifierParams]) - case tools.V11.IsSupported(network, height): + case tools.V20.IsSupported(network, height): return parse[*verifreg11.AddVerifierParams, string](txMetadata, jsonUnmarshaller[*verifreg11.AddVerifierParams]) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parse[*verifreg12.AddVerifierParams, string](txMetadata, jsonUnmarshaller[*verifreg12.AddVerifierParams]) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parse[*verifreg13.AddVerifierParams, string](txMetadata, jsonUnmarshaller[*verifreg13.AddVerifierParams]) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parse[*verifreg14.AddVerifierParams, string](txMetadata, jsonUnmarshaller[*verifreg14.AddVerifierParams]) - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parse[*verifreg15.AddVerifierParams, string](txMetadata, jsonUnmarshaller[*verifreg15.AddVerifierParams]) } return nil, nil diff --git a/actors/paymentChannel/paymentChannel.go b/actors/paymentChannel/paymentChannel.go index c78149cf..f1b921e4 100644 --- a/actors/paymentChannel/paymentChannel.go +++ b/actors/paymentChannel/paymentChannel.go @@ -20,21 +20,21 @@ type paymentChannelParams interface { func PaymentChannelConstructor(network string, height int64, raw []byte) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): return parse[*paychv8.ConstructorParams](raw) - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return parse[*paychv9.ConstructorParams](raw) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parse[*paychv10.ConstructorParams](raw) - case tools.V11.IsSupported(network, height): + case tools.V20.IsSupported(network, height): return parse[*paychv11.ConstructorParams](raw) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parse[*paychv12.ConstructorParams](raw) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parse[*paychv13.ConstructorParams](raw) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parse[*paychv14.ConstructorParams](raw) - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parse[*paychv15.ConstructorParams](raw) } return nil, nil @@ -42,21 +42,21 @@ func PaymentChannelConstructor(network string, height int64, raw []byte) (map[st func UpdateChannelState(network string, height int64, raw []byte) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): return parse[*paychv8.UpdateChannelStateParams](raw) - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return parse[*paychv9.UpdateChannelStateParams](raw) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parse[*paychv10.UpdateChannelStateParams](raw) - case tools.V11.IsSupported(network, height): + case tools.V20.IsSupported(network, height): return parse[*paychv11.UpdateChannelStateParams](raw) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parse[*paychv12.UpdateChannelStateParams](raw) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parse[*paychv13.UpdateChannelStateParams](raw) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parse[*paychv14.UpdateChannelStateParams](raw) - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parse[*paychv15.UpdateChannelStateParams](raw) } return nil, nil diff --git a/actors/power/power.go b/actors/power/power.go index e97234d0..bf40acd1 100644 --- a/actors/power/power.go +++ b/actors/power/power.go @@ -19,28 +19,28 @@ import ( func CurrentTotalPower(network string, msg *parser.LotusMessage, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): data, _, err := parse[*powerv8.CurrentTotalPowerReturn, *powerv8.CurrentTotalPowerReturn](msg, raw, rawReturn, false) return data, err - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): data, _, err := parse[*powerv9.CurrentTotalPowerReturn, *powerv9.CurrentTotalPowerReturn](msg, raw, rawReturn, false) return data, err - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): data, _, err := parse[*powerv10.CurrentTotalPowerReturn, *powerv10.CurrentTotalPowerReturn](msg, raw, rawReturn, false) return data, err - case tools.V11.IsSupported(network, height): + case tools.V19.IsSupported(network, height): data, _, err := parse[*powerv11.CurrentTotalPowerReturn, *powerv11.CurrentTotalPowerReturn](msg, raw, rawReturn, false) return data, err - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): data, _, err := parse[*powerv12.CurrentTotalPowerReturn, *powerv12.CurrentTotalPowerReturn](msg, raw, rawReturn, false) return data, err - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): data, _, err := parse[*powerv13.CurrentTotalPowerReturn, *powerv13.CurrentTotalPowerReturn](msg, raw, rawReturn, false) return data, err - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): data, _, err := parse[*powerv14.CurrentTotalPowerReturn, *powerv14.CurrentTotalPowerReturn](msg, raw, rawReturn, false) return data, err - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): data, _, err := parse[*powerv15.CurrentTotalPowerReturn, *powerv15.CurrentTotalPowerReturn](msg, raw, rawReturn, false) return data, err } @@ -54,28 +54,28 @@ func SubmitPoRepForBulkVerify(network string, msg *parser.LotusMessage, height i func PowerConstructor(network string, height int64, msg *parser.LotusMessage, raw []byte) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): data, _, err := parse[*powerv8.MinerConstructorParams, *powerv8.MinerConstructorParams](msg, raw, nil, false) return data, err - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): data, _, err := parse[*powerv9.MinerConstructorParams, *powerv9.MinerConstructorParams](msg, raw, nil, false) return data, err - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): data, _, err := parse[*powerv10.MinerConstructorParams, *powerv10.MinerConstructorParams](msg, raw, nil, false) return data, err - case tools.V11.IsSupported(network, height): + case tools.V19.IsSupported(network, height): data, _, err := parse[*powerv11.MinerConstructorParams, *powerv11.MinerConstructorParams](msg, raw, nil, false) return data, err - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): data, _, err := parse[*powerv12.MinerConstructorParams, *powerv12.MinerConstructorParams](msg, raw, nil, false) return data, err - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): data, _, err := parse[*powerv13.MinerConstructorParams, *powerv13.MinerConstructorParams](msg, raw, nil, false) return data, err - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): data, _, err := parse[*powerv14.MinerConstructorParams, *powerv14.MinerConstructorParams](msg, raw, nil, false) return data, err - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): data, _, err := parse[*powerv15.MinerConstructorParams, *powerv15.MinerConstructorParams](msg, raw, nil, false) return data, err } @@ -84,28 +84,28 @@ func PowerConstructor(network string, height int64, msg *parser.LotusMessage, ra func CreateMiner(network string, msg *parser.LotusMessage, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): data, _, err := parse[*powerv8.CreateMinerParams, *powerv8.CreateMinerReturn](msg, raw, rawReturn, true) return data, err - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): data, _, err := parse[*powerv9.CreateMinerParams, *powerv9.CreateMinerReturn](msg, raw, rawReturn, true) return data, err - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): data, _, err := parse[*powerv10.CreateMinerParams, *powerv10.CreateMinerReturn](msg, raw, rawReturn, true) return data, err - case tools.V11.IsSupported(network, height): + case tools.V19.IsSupported(network, height): data, _, err := parse[*powerv11.CreateMinerParams, *powerv11.CreateMinerReturn](msg, raw, rawReturn, true) return data, err - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): data, _, err := parse[*powerv12.CreateMinerParams, *powerv12.CreateMinerReturn](msg, raw, rawReturn, true) return data, err - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): data, _, err := parse[*powerv13.CreateMinerParams, *powerv13.CreateMinerReturn](msg, raw, rawReturn, true) return data, err - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): data, _, err := parse[*powerv14.CreateMinerParams, *powerv14.CreateMinerReturn](msg, raw, rawReturn, true) return data, err - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): data, _, err := parse[*powerv15.CreateMinerParams, *powerv15.CreateMinerReturn](msg, raw, rawReturn, true) return data, err } @@ -114,28 +114,28 @@ func CreateMiner(network string, msg *parser.LotusMessage, height int64, raw, ra func EnrollCronEvent(network string, msg *parser.LotusMessage, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): data, _, err := parse[*powerv8.EnrollCronEventParams, *powerv8.EnrollCronEventParams](msg, raw, rawReturn, true) return data, err - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): data, _, err := parse[*powerv9.EnrollCronEventParams, *powerv9.EnrollCronEventParams](msg, raw, rawReturn, true) return data, err - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): data, _, err := parse[*powerv10.EnrollCronEventParams, *powerv10.EnrollCronEventParams](msg, raw, rawReturn, true) return data, err - case tools.V11.IsSupported(network, height): + case tools.V19.IsSupported(network, height): data, _, err := parse[*powerv11.EnrollCronEventParams, *powerv11.EnrollCronEventParams](msg, raw, rawReturn, true) return data, err - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): data, _, err := parse[*powerv12.EnrollCronEventParams, *powerv12.EnrollCronEventParams](msg, raw, rawReturn, true) return data, err - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): data, _, err := parse[*powerv13.EnrollCronEventParams, *powerv13.EnrollCronEventParams](msg, raw, rawReturn, true) return data, err - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): data, _, err := parse[*powerv14.EnrollCronEventParams, *powerv14.EnrollCronEventParams](msg, raw, rawReturn, true) return data, err - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): data, _, err := parse[*powerv15.EnrollCronEventParams, *powerv15.EnrollCronEventParams](msg, raw, rawReturn, true) return data, err } @@ -144,28 +144,28 @@ func EnrollCronEvent(network string, msg *parser.LotusMessage, height int64, raw func UpdateClaimedPower(network string, msg *parser.LotusMessage, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): data, _, err := parse[*powerv8.UpdateClaimedPowerParams, *powerv8.UpdateClaimedPowerParams](msg, raw, rawReturn, true) return data, err - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): data, _, err := parse[*powerv9.UpdateClaimedPowerParams, *powerv9.UpdateClaimedPowerParams](msg, raw, rawReturn, true) return data, err - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): data, _, err := parse[*powerv10.UpdateClaimedPowerParams, *powerv10.UpdateClaimedPowerParams](msg, raw, rawReturn, true) return data, err - case tools.V11.IsSupported(network, height): + case tools.V19.IsSupported(network, height): data, _, err := parse[*powerv11.UpdateClaimedPowerParams, *powerv11.UpdateClaimedPowerParams](msg, raw, rawReturn, true) return data, err - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): data, _, err := parse[*powerv12.UpdateClaimedPowerParams, *powerv12.UpdateClaimedPowerParams](msg, raw, rawReturn, true) return data, err - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): data, _, err := parse[*powerv13.UpdateClaimedPowerParams, *powerv13.UpdateClaimedPowerParams](msg, raw, rawReturn, true) return data, err - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): data, _, err := parse[*powerv14.UpdateClaimedPowerParams, *powerv14.UpdateClaimedPowerParams](msg, raw, rawReturn, true) return data, err - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): data, _, err := parse[*powerv15.UpdateClaimedPowerParams, *powerv15.UpdateClaimedPowerParams](msg, raw, rawReturn, true) return data, err } @@ -174,28 +174,28 @@ func UpdateClaimedPower(network string, msg *parser.LotusMessage, height int64, func UpdatePledgeTotal(network string, msg *parser.LotusMessage, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): data, _, err := parse[*abi.TokenAmount, *abi.TokenAmount](msg, raw, rawReturn, false) return data, err - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): data, _, err := parse[*abi.TokenAmount, *abi.TokenAmount](msg, raw, rawReturn, false) return data, err - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): data, _, err := parse[*abi.TokenAmount, *abi.TokenAmount](msg, raw, rawReturn, false) return data, err - case tools.V11.IsSupported(network, height): + case tools.V19.IsSupported(network, height): data, _, err := parse[*abi.TokenAmount, *abi.TokenAmount](msg, raw, rawReturn, false) return data, err - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): data, _, err := parse[*abi.TokenAmount, *abi.TokenAmount](msg, raw, rawReturn, false) return data, err - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): data, _, err := parse[*abi.TokenAmount, *abi.TokenAmount](msg, raw, rawReturn, false) return data, err - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): data, _, err := parse[*abi.TokenAmount, *abi.TokenAmount](msg, raw, rawReturn, false) return data, err - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): data, _, err := parse[*abi.TokenAmount, *abi.TokenAmount](msg, raw, rawReturn, false) return data, err } @@ -204,26 +204,26 @@ func UpdatePledgeTotal(network string, msg *parser.LotusMessage, height int64, r func NetworkRawPower(network string, msg *parser.LotusMessage, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): return nil, fmt.Errorf("not supported") - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return nil, fmt.Errorf("not supported") - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): data, _, err := parse[*powerv10.NetworkRawPowerReturn, *powerv10.NetworkRawPowerReturn](msg, raw, rawReturn, false) return data, err - case tools.V11.IsSupported(network, height): + case tools.V19.IsSupported(network, height): data, _, err := parse[*powerv11.NetworkRawPowerReturn, *powerv11.NetworkRawPowerReturn](msg, raw, rawReturn, false) return data, err - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): data, _, err := parse[*powerv12.NetworkRawPowerReturn, *powerv12.NetworkRawPowerReturn](msg, raw, rawReturn, false) return data, err - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): data, _, err := parse[*powerv13.NetworkRawPowerReturn, *powerv13.NetworkRawPowerReturn](msg, raw, rawReturn, false) return data, err - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): data, _, err := parse[*powerv14.NetworkRawPowerReturn, *powerv14.NetworkRawPowerReturn](msg, raw, rawReturn, false) return data, err - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): data, _, err := parse[*powerv15.NetworkRawPowerReturn, *powerv15.NetworkRawPowerReturn](msg, raw, rawReturn, false) return data, err } @@ -232,26 +232,26 @@ func NetworkRawPower(network string, msg *parser.LotusMessage, height int64, raw func MinerRawPower(network string, msg *parser.LotusMessage, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): return nil, fmt.Errorf("not supported") - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return nil, fmt.Errorf("not supported") - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): data, _, err := parse[*powerv10.MinerRawPowerParams, *powerv10.MinerRawPowerReturn](msg, raw, rawReturn, true) return data, err - case tools.V11.IsSupported(network, height): + case tools.V19.IsSupported(network, height): data, _, err := parse[*powerv11.MinerRawPowerParams, *powerv11.MinerRawPowerReturn](msg, raw, rawReturn, true) return data, err - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): data, _, err := parse[*powerv12.MinerRawPowerParams, *powerv12.MinerRawPowerReturn](msg, raw, rawReturn, true) return data, err - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): data, _, err := parse[*powerv13.MinerRawPowerParams, *powerv13.MinerRawPowerReturn](msg, raw, rawReturn, true) return data, err - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): data, _, err := parse[*powerv14.MinerRawPowerParams, *powerv14.MinerRawPowerReturn](msg, raw, rawReturn, true) return data, err - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): data, _, err := parse[*powerv15.MinerRawPowerParams, *powerv15.MinerRawPowerReturn](msg, raw, rawReturn, true) return data, err } @@ -260,26 +260,26 @@ func MinerRawPower(network string, msg *parser.LotusMessage, height int64, raw, func MinerCount(network string, msg *parser.LotusMessage, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): return nil, fmt.Errorf("not supported") - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return nil, fmt.Errorf("not supported") - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): data, _, err := parse[*powerv10.MinerCountReturn, *powerv10.MinerCountReturn](msg, raw, rawReturn, false) return data, err - case tools.V11.IsSupported(network, height): + case tools.V19.IsSupported(network, height): data, _, err := parse[*powerv11.MinerCountReturn, *powerv11.MinerCountReturn](msg, raw, rawReturn, false) return data, err - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): data, _, err := parse[*powerv12.MinerCountReturn, *powerv12.MinerCountReturn](msg, raw, rawReturn, false) return data, err - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): data, _, err := parse[*powerv13.MinerCountReturn, *powerv13.MinerCountReturn](msg, raw, rawReturn, false) return data, err - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): data, _, err := parse[*powerv14.MinerCountReturn, *powerv14.MinerCountReturn](msg, raw, rawReturn, false) return data, err - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): data, _, err := parse[*powerv15.MinerCountReturn, *powerv15.MinerCountReturn](msg, raw, rawReturn, false) return data, err } @@ -288,26 +288,26 @@ func MinerCount(network string, msg *parser.LotusMessage, height int64, raw, raw func MinerConsensusCount(network string, msg *parser.LotusMessage, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): return nil, fmt.Errorf("not supported") - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return nil, fmt.Errorf("not supported") - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): data, _, err := parse[*powerv10.MinerConsensusCountReturn, *powerv10.MinerConsensusCountReturn](msg, raw, rawReturn, false) return data, err - case tools.V11.IsSupported(network, height): + case tools.V19.IsSupported(network, height): data, _, err := parse[*powerv11.MinerConsensusCountReturn, *powerv11.MinerConsensusCountReturn](msg, raw, rawReturn, false) return data, err - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): data, _, err := parse[*powerv12.MinerConsensusCountReturn, *powerv12.MinerConsensusCountReturn](msg, raw, rawReturn, false) return data, err - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): data, _, err := parse[*powerv13.MinerConsensusCountReturn, *powerv13.MinerConsensusCountReturn](msg, raw, rawReturn, false) return data, err - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): data, _, err := parse[*powerv14.MinerConsensusCountReturn, *powerv14.MinerConsensusCountReturn](msg, raw, rawReturn, false) return data, err - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): data, _, err := parse[*powerv15.MinerConsensusCountReturn, *powerv15.MinerConsensusCountReturn](msg, raw, rawReturn, false) return data, err } diff --git a/actors/reward/reward.go b/actors/reward/reward.go index 89fe3e62..6cef55da 100644 --- a/actors/reward/reward.go +++ b/actors/reward/reward.go @@ -19,21 +19,21 @@ func RewardConstructor(network string, height int64, raw []byte) (map[string]int func AwardBlockReward(network string, height int64, raw []byte) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): return parse[*rewardv8.AwardBlockRewardParams](raw) - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return parse[*rewardv9.AwardBlockRewardParams](raw) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parse[*rewardv10.AwardBlockRewardParams](raw) - case tools.V11.IsSupported(network, height): + case tools.V20.IsSupported(network, height): return parse[*rewardv11.AwardBlockRewardParams](raw) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parse[*rewardv12.AwardBlockRewardParams](raw) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parse[*rewardv13.AwardBlockRewardParams](raw) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parse[*rewardv14.AwardBlockRewardParams](raw) - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parse[*rewardv15.AwardBlockRewardParams](raw) } return nil, nil @@ -45,21 +45,21 @@ func UpdateNetworkKPI(network string, height int64, raw []byte) (map[string]inte func ThisEpochReward(network string, height int64, raw []byte) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): return parse[*rewardv8.ThisEpochRewardReturn](raw) - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return parse[*rewardv9.ThisEpochRewardReturn](raw) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parse[*rewardv10.ThisEpochRewardReturn](raw) - case tools.V11.IsSupported(network, height): + case tools.V20.IsSupported(network, height): return parse[*rewardv11.ThisEpochRewardReturn](raw) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parse[*rewardv12.ThisEpochRewardReturn](raw) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parse[*rewardv13.ThisEpochRewardReturn](raw) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parse[*rewardv14.ThisEpochRewardReturn](raw) - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parse[*rewardv15.ThisEpochRewardReturn](raw) } return nil, nil diff --git a/actors/verifiedRegistry/verifiedRegistry.go b/actors/verifiedRegistry/verifiedRegistry.go index 1c473cb5..f04495e9 100644 --- a/actors/verifiedRegistry/verifiedRegistry.go +++ b/actors/verifiedRegistry/verifiedRegistry.go @@ -18,21 +18,21 @@ import ( func AddVerifier(network string, height int64, raw []byte) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): return parse[*verifregv8.AddVerifierParams, *verifregv8.AddVerifierParams](raw, nil, false) - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return parse[*verifregv9.AddVerifierParams, *verifregv9.AddVerifierParams](raw, nil, false) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parse[*verifregv10.AddVerifierParams, *verifregv10.AddVerifierParams](raw, nil, false) - case tools.V11.IsSupported(network, height): + case tools.V19.IsSupported(network, height): return parse[*verifregv11.AddVerifierParams, *verifregv11.AddVerifierParams](raw, nil, false) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parse[*verifregv12.AddVerifierParams, *verifregv12.AddVerifierParams](raw, nil, false) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parse[*verifregv13.AddVerifierParams, *verifregv13.AddVerifierParams](raw, nil, false) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parse[*verifregv14.AddVerifierParams, *verifregv14.AddVerifierParams](raw, nil, false) - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parse[*verifregv15.AddVerifierParams, *verifregv15.AddVerifierParams](raw, nil, false) } return nil, nil @@ -44,21 +44,21 @@ func RemoveVerifier(network string, height int64, raw []byte) (map[string]interf func AddVerifiedClient(network string, height int64, raw []byte) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): return parse[*verifregv8.AddVerifiedClientParams, *verifregv8.AddVerifiedClientParams](raw, nil, false) - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return parse[*verifregv9.AddVerifiedClientParams, *verifregv9.AddVerifiedClientParams](raw, nil, false) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parse[*verifregv10.AddVerifiedClientParams, *verifregv10.AddVerifiedClientParams](raw, nil, false) - case tools.V11.IsSupported(network, height): + case tools.V19.IsSupported(network, height): return parse[*verifregv11.AddVerifiedClientParams, *verifregv11.AddVerifiedClientParams](raw, nil, false) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parse[*verifregv12.AddVerifiedClientParams, *verifregv12.AddVerifiedClientParams](raw, nil, false) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parse[*verifregv13.AddVerifiedClientParams, *verifregv13.AddVerifiedClientParams](raw, nil, false) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parse[*verifregv14.AddVerifiedClientParams, *verifregv14.AddVerifiedClientParams](raw, nil, false) - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parse[*verifregv15.AddVerifiedClientParams, *verifregv15.AddVerifiedClientParams](raw, nil, false) } return nil, nil @@ -66,21 +66,21 @@ func AddVerifiedClient(network string, height int64, raw []byte) (map[string]int func UseBytes(network string, height int64, raw []byte) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): return parse[*verifregv8.UseBytesParams, *verifregv8.UseBytesParams](raw, nil, false) - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return parse[*verifregv9.UseBytesParams, *verifregv9.UseBytesParams](raw, nil, false) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parse[*verifregv10.UseBytesParams, *verifregv10.UseBytesParams](raw, nil, false) - case tools.V11.IsSupported(network, height): + case tools.V19.IsSupported(network, height): return parse[*verifregv11.UseBytesParams, *verifregv11.UseBytesParams](raw, nil, false) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parse[*verifregv12.UseBytesParams, *verifregv12.UseBytesParams](raw, nil, false) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parse[*verifregv13.UseBytesParams, *verifregv13.UseBytesParams](raw, nil, false) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parse[*verifregv14.UseBytesParams, *verifregv14.UseBytesParams](raw, nil, false) - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parse[*verifregv15.UseBytesParams, *verifregv15.UseBytesParams](raw, nil, false) } return nil, nil @@ -88,21 +88,21 @@ func UseBytes(network string, height int64, raw []byte) (map[string]interface{}, func RestoreBytes(network string, height int64, raw []byte) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): return parse[*verifregv8.RestoreBytesParams, *verifregv8.RestoreBytesParams](raw, nil, false) - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return parse[*verifregv9.RestoreBytesParams, *verifregv9.RestoreBytesParams](raw, nil, false) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parse[*verifregv10.RestoreBytesParams, *verifregv10.RestoreBytesParams](raw, nil, false) - case tools.V11.IsSupported(network, height): + case tools.V19.IsSupported(network, height): return parse[*verifregv11.RestoreBytesParams, *verifregv11.RestoreBytesParams](raw, nil, false) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parse[*verifregv12.RestoreBytesParams, *verifregv12.RestoreBytesParams](raw, nil, false) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parse[*verifregv13.RestoreBytesParams, *verifregv13.RestoreBytesParams](raw, nil, false) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parse[*verifregv14.RestoreBytesParams, *verifregv14.RestoreBytesParams](raw, nil, false) - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parse[*verifregv15.RestoreBytesParams, *verifregv15.RestoreBytesParams](raw, nil, false) } return nil, nil @@ -110,21 +110,21 @@ func RestoreBytes(network string, height int64, raw []byte) (map[string]interfac func RemoveVerifiedClientDataCap(network string, height int64, raw []byte) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): return parse[*verifregv8.DataCap, *verifregv8.DataCap](raw, nil, false) - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return parse[*verifregv9.DataCap, *verifregv9.DataCap](raw, nil, false) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parse[*verifregv10.DataCap, *verifregv10.DataCap](raw, nil, false) - case tools.V11.IsSupported(network, height): + case tools.V19.IsSupported(network, height): return parse[*verifregv11.DataCap, *verifregv11.DataCap](raw, nil, false) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parse[*verifregv12.DataCap, *verifregv12.DataCap](raw, nil, false) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parse[*verifregv13.DataCap, *verifregv13.DataCap](raw, nil, false) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parse[*verifregv14.DataCap, *verifregv14.DataCap](raw, nil, false) - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parse[*verifregv15.DataCap, *verifregv15.DataCap](raw, nil, false) } return nil, nil @@ -132,21 +132,21 @@ func RemoveVerifiedClientDataCap(network string, height int64, raw []byte) (map[ func RemoveExpiredAllocations(network string, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): return nil, fmt.Errorf("not supported") - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return parse[*verifregv9.RemoveExpiredAllocationsParams, *verifregv9.RemoveExpiredAllocationsReturn](raw, rawReturn, true) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parse[*verifregv10.RemoveExpiredAllocationsParams, *verifregv10.RemoveExpiredAllocationsReturn](raw, rawReturn, true) - case tools.V11.IsSupported(network, height): + case tools.V19.IsSupported(network, height): return parse[*verifregv11.RemoveExpiredAllocationsParams, *verifregv11.RemoveExpiredAllocationsReturn](raw, rawReturn, true) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parse[*verifregv12.RemoveExpiredAllocationsParams, *verifregv12.RemoveExpiredAllocationsReturn](raw, rawReturn, true) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parse[*verifregv13.RemoveExpiredAllocationsParams, *verifregv13.RemoveExpiredAllocationsReturn](raw, rawReturn, true) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parse[*verifregv14.RemoveExpiredAllocationsParams, *verifregv14.RemoveExpiredAllocationsReturn](raw, rawReturn, true) - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parse[*verifregv15.RemoveExpiredAllocationsParams, *verifregv15.RemoveExpiredAllocationsReturn](raw, rawReturn, true) } return nil, nil @@ -154,21 +154,21 @@ func RemoveExpiredAllocations(network string, height int64, raw, rawReturn []byt func Deprecated1(network string, height int64, raw []byte) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): return parse[*verifregv8.RestoreBytesParams, *verifregv8.RestoreBytesParams](raw, nil, false) - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return parse[*verifregv9.RestoreBytesParams, *verifregv9.RestoreBytesParams](raw, nil, false) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parse[*verifregv10.RestoreBytesParams, *verifregv10.RestoreBytesParams](raw, nil, false) - case tools.V11.IsSupported(network, height): + case tools.V19.IsSupported(network, height): return parse[*verifregv11.RestoreBytesParams, *verifregv11.RestoreBytesParams](raw, nil, false) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parse[*verifregv12.RestoreBytesParams, *verifregv12.RestoreBytesParams](raw, nil, false) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parse[*verifregv13.RestoreBytesParams, *verifregv13.RestoreBytesParams](raw, nil, false) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parse[*verifregv14.RestoreBytesParams, *verifregv14.RestoreBytesParams](raw, nil, false) - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parse[*verifregv15.RestoreBytesParams, *verifregv15.RestoreBytesParams](raw, nil, false) } return nil, nil @@ -176,21 +176,21 @@ func Deprecated1(network string, height int64, raw []byte) (map[string]interface func Deprecated2(network string, height int64, raw []byte) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): return parse[*verifregv8.UseBytesParams, *verifregv8.UseBytesParams](raw, nil, false) - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return parse[*verifregv9.UseBytesParams, *verifregv9.UseBytesParams](raw, nil, false) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parse[*verifregv10.UseBytesParams, *verifregv10.UseBytesParams](raw, nil, false) - case tools.V11.IsSupported(network, height): + case tools.V19.IsSupported(network, height): return parse[*verifregv11.UseBytesParams, *verifregv11.UseBytesParams](raw, nil, false) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parse[*verifregv12.UseBytesParams, *verifregv12.UseBytesParams](raw, nil, false) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parse[*verifregv13.UseBytesParams, *verifregv13.UseBytesParams](raw, nil, false) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parse[*verifregv14.UseBytesParams, *verifregv14.UseBytesParams](raw, nil, false) - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parse[*verifregv15.UseBytesParams, *verifregv15.UseBytesParams](raw, nil, false) } return nil, nil @@ -198,21 +198,21 @@ func Deprecated2(network string, height int64, raw []byte) (map[string]interface func ClaimAllocations(network string, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): return nil, fmt.Errorf("not supported") - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return parse[*verifregv9.ClaimAllocationsParams, *verifregv9.ClaimAllocationsReturn](raw, rawReturn, true) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parse[*verifregv10.ClaimAllocationsParams, *verifregv10.ClaimAllocationsReturn](raw, rawReturn, true) - case tools.V11.IsSupported(network, height): + case tools.V19.IsSupported(network, height): return parse[*verifregv11.ClaimAllocationsParams, *verifregv11.ClaimAllocationsReturn](raw, rawReturn, true) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parse[*verifregv12.ClaimAllocationsParams, *verifregv12.ClaimAllocationsReturn](raw, rawReturn, true) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parse[*verifregv13.ClaimAllocationsParams, *verifregv13.ClaimAllocationsReturn](raw, rawReturn, true) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parse[*verifregv14.ClaimAllocationsParams, *verifregv14.ClaimAllocationsReturn](raw, rawReturn, true) - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parse[*verifregv15.ClaimAllocationsParams, *verifregv15.ClaimAllocationsReturn](raw, rawReturn, true) } return nil, nil @@ -220,21 +220,21 @@ func ClaimAllocations(network string, height int64, raw, rawReturn []byte) (map[ func GetClaims(network string, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): return nil, fmt.Errorf("not supported") - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return parse[*verifregv9.GetClaimsParams, *verifregv9.GetClaimsReturn](raw, rawReturn, true) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parse[*verifregv10.GetClaimsParams, *verifregv10.GetClaimsReturn](raw, rawReturn, true) - case tools.V11.IsSupported(network, height): + case tools.V19.IsSupported(network, height): return parse[*verifregv11.GetClaimsParams, *verifregv11.GetClaimsReturn](raw, rawReturn, true) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parse[*verifregv12.GetClaimsParams, *verifregv12.GetClaimsReturn](raw, rawReturn, true) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parse[*verifregv13.GetClaimsParams, *verifregv13.GetClaimsReturn](raw, rawReturn, true) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parse[*verifregv14.GetClaimsParams, *verifregv14.GetClaimsReturn](raw, rawReturn, true) - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parse[*verifregv15.GetClaimsParams, *verifregv15.GetClaimsReturn](raw, rawReturn, true) } return nil, nil @@ -242,21 +242,21 @@ func GetClaims(network string, height int64, raw, rawReturn []byte) (map[string] func ExtendClaimTerms(network string, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): return nil, fmt.Errorf("not supported") - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return parse[*verifregv9.ExtendClaimTermsParams, *verifregv9.ExtendClaimTermsReturn](raw, rawReturn, true) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parse[*verifregv10.ExtendClaimTermsParams, *verifregv10.ExtendClaimTermsReturn](raw, rawReturn, true) - case tools.V11.IsSupported(network, height): + case tools.V19.IsSupported(network, height): return parse[*verifregv11.ExtendClaimTermsParams, *verifregv11.ExtendClaimTermsReturn](raw, rawReturn, true) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parse[*verifregv12.ExtendClaimTermsParams, *verifregv12.ExtendClaimTermsReturn](raw, rawReturn, true) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parse[*verifregv13.ExtendClaimTermsParams, *verifregv13.ExtendClaimTermsReturn](raw, rawReturn, true) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parse[*verifregv14.ExtendClaimTermsParams, *verifregv14.ExtendClaimTermsReturn](raw, rawReturn, true) - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parse[*verifregv15.ExtendClaimTermsParams, *verifregv15.ExtendClaimTermsReturn](raw, rawReturn, true) } return nil, nil @@ -264,21 +264,21 @@ func ExtendClaimTerms(network string, height int64, raw, rawReturn []byte) (map[ func RemoveExpiredClaims(network string, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): return nil, fmt.Errorf("not supported") - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return parse[*verifregv9.RemoveExpiredClaimsParams, *verifregv9.RemoveExpiredClaimsReturn](raw, rawReturn, true) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parse[*verifregv10.RemoveExpiredClaimsParams, *verifregv10.RemoveExpiredClaimsReturn](raw, rawReturn, true) - case tools.V11.IsSupported(network, height): + case tools.V19.IsSupported(network, height): return parse[*verifregv11.RemoveExpiredClaimsParams, *verifregv11.RemoveExpiredClaimsReturn](raw, rawReturn, true) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parse[*verifregv12.RemoveExpiredClaimsParams, *verifregv12.RemoveExpiredClaimsReturn](raw, rawReturn, true) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parse[*verifregv13.RemoveExpiredClaimsParams, *verifregv13.RemoveExpiredClaimsReturn](raw, rawReturn, true) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parse[*verifregv14.RemoveExpiredClaimsParams, *verifregv14.RemoveExpiredClaimsReturn](raw, rawReturn, true) - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parse[*verifregv15.RemoveExpiredClaimsParams, *verifregv15.RemoveExpiredClaimsReturn](raw, rawReturn, true) } return nil, nil @@ -286,21 +286,21 @@ func RemoveExpiredClaims(network string, height int64, raw, rawReturn []byte) (m func VerifregUniversalReceiverHook(network string, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch { - case tools.V8.IsSupported(network, height): + case tools.V16.IsSupported(network, height): return nil, fmt.Errorf("not supported") - case tools.V9.IsSupported(network, height): + case tools.V17.IsSupported(network, height): return parse[*verifregv9.UniversalReceiverParams, *verifregv9.AllocationsResponse](raw, rawReturn, true) - case tools.V10.IsSupported(network, height): + case tools.V18.IsSupported(network, height): return parse[*verifregv10.UniversalReceiverParams, *verifregv10.AllocationsResponse](raw, rawReturn, true) - case tools.V11.IsSupported(network, height): + case tools.V19.IsSupported(network, height): return parse[*verifregv11.UniversalReceiverParams, *verifregv11.AllocationsResponse](raw, rawReturn, true) - case tools.V12.IsSupported(network, height): + case tools.V21.IsSupported(network, height): return parse[*verifregv12.UniversalReceiverParams, *verifregv12.AllocationsResponse](raw, rawReturn, true) - case tools.V13.IsSupported(network, height): + case tools.V22.IsSupported(network, height): return parse[*verifregv13.UniversalReceiverParams, *verifregv13.AllocationsResponse](raw, rawReturn, true) - case tools.V14.IsSupported(network, height): + case tools.V23.IsSupported(network, height): return parse[*verifregv14.UniversalReceiverParams, *verifregv14.AllocationsResponse](raw, rawReturn, true) - case tools.V15.IsSupported(network, height): + case tools.V24.IsSupported(network, height): return parse[*verifregv15.UniversalReceiverParams, *verifregv15.AllocationsResponse](raw, rawReturn, true) } return nil, nil diff --git a/tools/version_mapping.go b/tools/version_mapping.go index a8a48346..636259b4 100644 --- a/tools/version_mapping.go +++ b/tools/version_mapping.go @@ -3,29 +3,31 @@ package tools import "fmt" var ( - LatestVersion version = version{calibration: 22000, mainnet: 22000} V1 version = version{calibration: 0, mainnet: 0} - V2 version = version{calibration: 100, mainnet: 100} - V3 version = version{calibration: 1000, mainnet: 1000} - V4 version = version{calibration: 2000, mainnet: 2000} - V5 version = version{calibration: 3000, mainnet: 3000} - V6 version = version{calibration: 4000, mainnet: 4000} - V7 version = version{calibration: 5000, mainnet: 5000} - V8 version = version{calibration: 6000, mainnet: 6000} - V9 version = version{calibration: 7000, mainnet: 7000} - V10 version = version{calibration: 8000, mainnet: 8000} - V11 version = version{calibration: 9000, mainnet: 9000} - V12 version = version{calibration: 10000, mainnet: 10000} - V13 version = version{calibration: 11000, mainnet: 11000} - V14 version = version{calibration: 12000, mainnet: 12000} - V15 version = version{calibration: 13000, mainnet: 13000} - V16 version = version{calibration: 14000, mainnet: 14000} - V17 version = version{calibration: 15000, mainnet: 15000} - V18 version = version{calibration: 16000, mainnet: 16000} - V19 version = version{calibration: 17000, mainnet: 17000} - V20 version = version{calibration: 18000, mainnet: 18000} - V21 version = version{calibration: 19000, mainnet: 19000} - V22 version = version{calibration: 20000, mainnet: 20000} + V2 version = version{calibration: 0, mainnet: 0} + V3 version = version{calibration: 0, mainnet: 0} + V4 version = version{calibration: 0, mainnet: 0} + V5 version = version{calibration: 0, mainnet: 0} + V6 version = version{calibration: 0, mainnet: 0} + V7 version = version{calibration: 0, mainnet: 0} + V8 version = version{calibration: 0, mainnet: 170000} + V9 version = version{calibration: 0, mainnet: 265200} + V10 version = version{calibration: 0, mainnet: 550321} + V11 version = version{calibration: 0, mainnet: 665280} + V12 version = version{calibration: 193789, mainnet: 712320} + V13 version = version{calibration: 0, mainnet: 892800} // calibration reset + V14 version = version{calibration: 312746, mainnet: 1231620} + V15 version = version{calibration: 682006, mainnet: 1594680} + V16 version = version{calibration: 1044660, mainnet: 1960320} + V17 version = version{calibration: 16800, mainnet: 2383680} // calibration reset + V18 version = version{calibration: 322354, mainnet: 2683348} + V19 version = version{calibration: 489094, mainnet: 2809800} + V20 version = version{calibration: 492214, mainnet: 2809800} + V21 version = version{calibration: 1108174, mainnet: 3469380} + V22 version = version{calibration: 1427974, mainnet: 3817920} + V23 version = version{calibration: 1779094, mainnet: 4154640} + V24 version = version{calibration: 2081674, mainnet: 4461240} + LatestVersion version = V24 ) type version struct { From 731a4bd65b6659b7659993c698414d443b287cbb Mon Sep 17 00:00:00 2001 From: Eric Mokaya Date: Wed, 22 Jan 2025 19:55:39 +0300 Subject: [PATCH 13/16] fix: add version tests and fixes --- tools/testutil.go | 6 +-- tools/tools_test.go | 31 +++++++++++++ tools/version_mapping.go | 97 +++++++++++++++++++++++++--------------- 3 files changed, 96 insertions(+), 38 deletions(-) diff --git a/tools/testutil.go b/tools/testutil.go index 05d45225..c8848a4a 100644 --- a/tools/testutil.go +++ b/tools/testutil.go @@ -168,9 +168,9 @@ type TestCase[T any] struct { Address *types.AddressInfo } -func LoadTestData[T any](fnName string, expected map[string]any) ([]TestCase[T], error) { +func LoadTestData[T any](fnName string, network string, expected map[string]any) ([]TestCase[T], error) { var tests []TestCase[T] - for _, version := range GetSupportedVersions() { + for _, version := range GetSupportedVersions(network) { versionData := expected[version.String()] if versionData == nil { @@ -190,7 +190,7 @@ func LoadTestData[T any](fnName string, expected map[string]any) ([]TestCase[T], Name: fnName, Version: version.String(), Url: NodeUrl, - Height: int64(version), + Height: version.Height(), Expected: fnData.(T), }) } diff --git a/tools/tools_test.go b/tools/tools_test.go index b33a8bed..9267f49c 100644 --- a/tools/tools_test.go +++ b/tools/tools_test.go @@ -34,6 +34,37 @@ func TestBuildTipSetKeyHash(t *testing.T) { } } +func TestIsSupported(t *testing.T) { + tests := []struct { + name string + version version + network string + height int64 + want bool + }{ + + {name: "V7 on calibration", version: V7, network: "calibration", height: 2383680, want: false}, + {name: "V7 on mainnet", version: V7, network: "mainnet", height: 170000, want: false}, + {name: "V7 on calibration", version: V7, network: "calibration", height: 0, want: false}, + {name: "V7 on mainnet", version: V7, network: "mainnet", height: 10000, want: true}, + + {name: "V9 on calibration", version: V9, network: "calibration", height: 265100, want: false}, + {name: "V9 on mainnet", version: V9, network: "mainnet", height: 265201, want: true}, + {name: "V9 on calibration", version: V9, network: "calibration", height: 265200, want: false}, + {name: "V9 on mainnet", version: V9, network: "mainnet", height: 265200, want: false}, + + {name: "V24 on calibration", version: V24, network: "calibration", height: 2081674, want: true}, + {name: "V24 on mainnet", version: V24, network: "mainnet", height: 1427974, want: false}, + {name: "V24 on calibration", version: V24, network: "calibration", height: 2081672, want: false}, + {name: "V24 on mainnet", version: V24, network: "mainnet", height: 4461240, want: true}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + require.Equal(t, tt.want, tt.version.IsSupported(tt.network, tt.height)) + }) + } +} + /* func TestBuildCidFromMessageTrace(t *testing.T) { h1, err := multihash.Sum([]byte("TEST"), multihash.SHA2_256, -1) diff --git a/tools/version_mapping.go b/tools/version_mapping.go index 636259b4..114912c0 100644 --- a/tools/version_mapping.go +++ b/tools/version_mapping.go @@ -2,46 +2,63 @@ package tools import "fmt" -var ( - V1 version = version{calibration: 0, mainnet: 0} - V2 version = version{calibration: 0, mainnet: 0} - V3 version = version{calibration: 0, mainnet: 0} - V4 version = version{calibration: 0, mainnet: 0} - V5 version = version{calibration: 0, mainnet: 0} - V6 version = version{calibration: 0, mainnet: 0} - V7 version = version{calibration: 0, mainnet: 0} - V8 version = version{calibration: 0, mainnet: 170000} - V9 version = version{calibration: 0, mainnet: 265200} - V10 version = version{calibration: 0, mainnet: 550321} - V11 version = version{calibration: 0, mainnet: 665280} - V12 version = version{calibration: 193789, mainnet: 712320} - V13 version = version{calibration: 0, mainnet: 892800} // calibration reset - V14 version = version{calibration: 312746, mainnet: 1231620} - V15 version = version{calibration: 682006, mainnet: 1594680} - V16 version = version{calibration: 1044660, mainnet: 1960320} - V17 version = version{calibration: 16800, mainnet: 2383680} // calibration reset - V18 version = version{calibration: 322354, mainnet: 2683348} - V19 version = version{calibration: 489094, mainnet: 2809800} - V20 version = version{calibration: 492214, mainnet: 2809800} - V21 version = version{calibration: 1108174, mainnet: 3469380} - V22 version = version{calibration: 1427974, mainnet: 3817920} - V23 version = version{calibration: 1779094, mainnet: 4154640} - V24 version = version{calibration: 2081674, mainnet: 4461240} - LatestVersion version = V24 -) - type version struct { calibration int64 mainnet int64 + + nodeVersion int64 + currentNetwork string } -var supportedVersions = []version{V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22} +var ( + supportedVersions = []version{V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22} + V1 version = version{calibration: 0, mainnet: 0, nodeVersion: 1} + V2 version = version{calibration: 0, mainnet: 0, nodeVersion: 2} + V3 version = version{calibration: 0, mainnet: 0, nodeVersion: 3} + V4 version = version{calibration: 0, mainnet: 0, nodeVersion: 4} + V5 version = version{calibration: 0, mainnet: 0, nodeVersion: 5} + V6 version = version{calibration: 0, mainnet: 0, nodeVersion: 6} + V7 version = version{calibration: 0, mainnet: 0, nodeVersion: 7} + V8 version = version{calibration: 0, mainnet: 170000, nodeVersion: 8} + V9 version = version{calibration: 0, mainnet: 265200, nodeVersion: 9} + V10 version = version{calibration: 0, mainnet: 550321, nodeVersion: 10} + V11 version = version{calibration: 0, mainnet: 665280, nodeVersion: 11} + V12 version = version{calibration: 193789, mainnet: 712320, nodeVersion: 12} + V13 version = version{calibration: 0, mainnet: 892800, nodeVersion: 13} // calibration reset + V14 version = version{calibration: 312746, mainnet: 1231620, nodeVersion: 14} + V15 version = version{calibration: 682006, mainnet: 1594680, nodeVersion: 15} + V16 version = version{calibration: 1044660, mainnet: 1960320, nodeVersion: 16} + V17 version = version{calibration: 16800, mainnet: 2383680, nodeVersion: 17} // calibration reset + V18 version = version{calibration: 322354, mainnet: 2683348, nodeVersion: 18} + V19 version = version{calibration: 489094, mainnet: 2809800, nodeVersion: 19} + V20 version = version{calibration: 492214, mainnet: 2809800, nodeVersion: 20} + V21 version = version{calibration: 1108174, mainnet: 3469380, nodeVersion: 21} + V22 version = version{calibration: 1427974, mainnet: 3817920, nodeVersion: 22} + V23 version = version{calibration: 1779094, mainnet: 4154640, nodeVersion: 23} + V24 version = version{calibration: 2081674, mainnet: 4461240, nodeVersion: 24} + LatestVersion version = V24 +) func (v version) IsSupported(network string, height int64) bool { if network == "calibration" { - return height <= v.calibration + if height >= LatestVersion.calibration { + return v == LatestVersion + } + // check if the height is greater than the current version but less than the next version + if height > v.calibration && height < v.next().calibration { + return true + } + } else { + if height >= LatestVersion.mainnet { + return v == LatestVersion + } + // check if the height is greater than the current version but less than the next version + if height > v.mainnet && height < v.next().mainnet { + return true + } } - return height <= v.mainnet + + return false } func (v version) next() version { @@ -57,11 +74,21 @@ func (v version) next() version { } func (v version) String() string { - return fmt.Sprintf("V%d", v.startHeight) + return fmt.Sprintf("V%d", v.nodeVersion) +} + +func (v version) Height() int64 { + if v.currentNetwork == "calibration" { + return v.calibration + } + return v.mainnet } -func GetSupportedVersions() []version { - // Create a new slice with same length and copy all elements + +func GetSupportedVersions(network string) []version { result := make([]version, len(supportedVersions)) - copy(result, supportedVersions) + for _, v := range supportedVersions { + v.currentNetwork = network + result = append(result, v) + } return result } From 46b365065618a492788283dd81ca98c5d4cbc740 Mon Sep 17 00:00:00 2001 From: Eric Mokaya Date: Wed, 22 Jan 2025 20:03:59 +0300 Subject: [PATCH 14/16] test: update tests --- actors/account/account_test.go | 7 ++- actors/cron/cron_test.go | 4 +- actors/datacap/allowance_test.go | 8 ++-- actors/datacap/burn_test.go | 6 +-- actors/datacap/datacap_test.go | 9 ++-- actors/datacap/granularity_test.go | 2 +- actors/datacap/mint_test.go | 2 +- actors/datacap/transfer_test.go | 2 +- actors/eam/create_test.go | 9 ++-- actors/evm/evm_test.go | 16 ++++--- actors/init/int_test.go | 9 ++-- actors/market/market_test.go | 45 ++++++++++--------- actors/miner/address_test.go | 16 +++---- actors/miner/balance_test.go | 6 +-- actors/miner/miner_test.go | 29 ++++++------ actors/miner/sector_test.go | 24 +++++----- actors/multisig/multisig_test.go | 18 ++++---- actors/multisig/values_test.go | 26 +++++------ actors/multisig/verifier_test.go | 2 +- actors/paymentChannel/paymentChannel_test.go | 7 ++- actors/power/power_test.go | 25 ++++++----- actors/reward/reward_test.go | 11 +++-- .../verifiedRegistry/verifiedRegistry_test.go | 31 +++++++------ tools/testutil.go | 2 +- 24 files changed, 176 insertions(+), 140 deletions(-) diff --git a/actors/account/account_test.go b/actors/account/account_test.go index ff9925ac..28136df4 100644 --- a/actors/account/account_test.go +++ b/actors/account/account_test.go @@ -20,8 +20,11 @@ var expectedData []byte var expected map[string]any var lib *rosettaFilecoinLib.RosettaConstructionFilecoin +var network string + func TestMain(m *testing.M) { var err error + network = "mainnet" lib, err = tools.GetLib(tools.NodeUrl) if err != nil { panic(err) @@ -35,7 +38,7 @@ func TestMain(m *testing.M) { } func TestAuthenticateMessage(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("AuthenticateMessage", expected) + tests, err := tools.LoadTestData[map[string]any](network, "AuthenticateMessage", expected) require.NoError(t, err) for _, tt := range tests { t.Run(tt.Name, func(t *testing.T) { @@ -55,7 +58,7 @@ func TestAuthenticateMessage(t *testing.T) { } func TestPubkeyAddress(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("PubkeyAddress", expected) + tests, err := tools.LoadTestData[map[string]any](network, "PubkeyAddress", expected) require.NoError(t, err) for _, tt := range tests { diff --git a/actors/cron/cron_test.go b/actors/cron/cron_test.go index 17877da4..646fb58c 100644 --- a/actors/cron/cron_test.go +++ b/actors/cron/cron_test.go @@ -14,8 +14,10 @@ import ( //go:embed expected.json var expectedData []byte var expected map[string]any +var network string func TestMain(m *testing.M) { + network = "mainnet" if err := json.Unmarshal(expectedData, &expected); err != nil { panic(err) } @@ -25,7 +27,7 @@ func TestMain(m *testing.M) { type testFn func(network string, height int64, raw []byte) (map[string]interface{}, error) func TestCronConstructor(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("CronConstructor", expected) + tests, err := tools.LoadTestData[map[string]any](network, "CronConstructor", expected) require.NoError(t, err) runTest(t, cron.CronConstructor, tests) } diff --git a/actors/datacap/allowance_test.go b/actors/datacap/allowance_test.go index 5debae13..896b03d4 100644 --- a/actors/datacap/allowance_test.go +++ b/actors/datacap/allowance_test.go @@ -13,28 +13,28 @@ import ( type testFn func(network string, height int64, raw, rawReturn []byte) (map[string]interface{}, error) func TestIncreaseAllowance(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("IncreaseAllowance", expected) + tests, err := tools.LoadTestData[map[string]any](network, "IncreaseAllowance", expected) require.NoError(t, err) runTest(t, datacap.IncreaseAllowance, tests) } func TestDecreaseAllowance(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("DecreaseAllowance", expected) + tests, err := tools.LoadTestData[map[string]any](network, "DecreaseAllowance", expected) require.NoError(t, err) runTest(t, datacap.DecreaseAllowance, tests) } func TestRevokeAllowance(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("RevokeAllowance", expected) + tests, err := tools.LoadTestData[map[string]any](network, "RevokeAllowance", expected) require.NoError(t, err) runTest(t, datacap.RevokeAllowance, tests) } func TestGetAllowance(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("GetAllowance", expected) + tests, err := tools.LoadTestData[map[string]any](network, "GetAllowance", expected) require.NoError(t, err) runTest(t, datacap.GetAllowance, tests) diff --git a/actors/datacap/burn_test.go b/actors/datacap/burn_test.go index c03d0774..a78344dc 100644 --- a/actors/datacap/burn_test.go +++ b/actors/datacap/burn_test.go @@ -9,21 +9,21 @@ import ( ) func TestBurnExported(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("BurnExported", expected) + tests, err := tools.LoadTestData[map[string]any](network, "BurnExported", expected) require.NoError(t, err) runTest(t, datacap.BurnExported, tests) } func TestBurnFromExported(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("BurnFromExported", expected) + tests, err := tools.LoadTestData[map[string]any](network, "BurnFromExported", expected) require.NoError(t, err) runTest(t, datacap.BurnFromExported, tests) } func TestDestroyExported(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("DestroyExported", expected) + tests, err := tools.LoadTestData[map[string]any](network, "DestroyExported", expected) require.NoError(t, err) runTest(t, datacap.DestroyExported, tests) diff --git a/actors/datacap/datacap_test.go b/actors/datacap/datacap_test.go index 2d4b65e8..404b22cc 100644 --- a/actors/datacap/datacap_test.go +++ b/actors/datacap/datacap_test.go @@ -16,7 +16,10 @@ import ( var expectedData []byte var expected map[string]any +var network string + func TestMain(m *testing.M) { + network = "mainnet" if err := json.Unmarshal(expectedData, &expected); err != nil { panic(err) } @@ -24,21 +27,21 @@ func TestMain(m *testing.M) { } func TestNameExported(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("NameExported", expected) + tests, err := tools.LoadTestData[map[string]any](network, "NameExported", expected) require.NoError(t, err) runDatacapTest(t, datacap.NameExported, tests) } func TestSymbolExported(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("SymbolExported", expected) + tests, err := tools.LoadTestData[map[string]any](network, "SymbolExported", expected) require.NoError(t, err) runDatacapTest(t, datacap.SymbolExported, tests) } func TestTotalSupplyExported(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("TotalSupplyExported", expected) + tests, err := tools.LoadTestData[map[string]any](network, "TotalSupplyExported", expected) require.NoError(t, err) runDatacapTest(t, datacap.TotalSupplyExported, tests) diff --git a/actors/datacap/granularity_test.go b/actors/datacap/granularity_test.go index ce65a1cb..28c8b9e2 100644 --- a/actors/datacap/granularity_test.go +++ b/actors/datacap/granularity_test.go @@ -10,7 +10,7 @@ import ( ) func TestGranularityExported(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("GranularityExported", expected) + tests, err := tools.LoadTestData[map[string]any](network, "GranularityExported", expected) require.NoError(t, err) for _, tt := range tests { diff --git a/actors/datacap/mint_test.go b/actors/datacap/mint_test.go index 79cb223d..abc07a31 100644 --- a/actors/datacap/mint_test.go +++ b/actors/datacap/mint_test.go @@ -9,7 +9,7 @@ import ( ) func TestMintExported(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("MintExported", expected) + tests, err := tools.LoadTestData[map[string]any](network, "MintExported", expected) require.NoError(t, err) runTest(t, datacap.MintExported, tests) diff --git a/actors/datacap/transfer_test.go b/actors/datacap/transfer_test.go index d1be5919..6d372426 100644 --- a/actors/datacap/transfer_test.go +++ b/actors/datacap/transfer_test.go @@ -9,7 +9,7 @@ import ( ) func TestTransferExported(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("TransferExported", expected) + tests, err := tools.LoadTestData[map[string]any](network, "TransferExported", expected) require.NoError(t, err) runTest(t, datacap.TransferExported, tests) diff --git a/actors/eam/create_test.go b/actors/eam/create_test.go index edc2bde5..97aad8dc 100644 --- a/actors/eam/create_test.go +++ b/actors/eam/create_test.go @@ -14,11 +14,14 @@ import ( "github.com/zondax/fil-parser/types" ) +var network string + //go:embed expected.json var expectedData []byte var expected map[string]any func TestMain(m *testing.M) { + network = "mainnet" if err := json.Unmarshal(expectedData, &expected); err != nil { panic(err) } @@ -28,21 +31,21 @@ func TestMain(m *testing.M) { type testFn func(network string, height int64, raw, rawReturn []byte, msgCid cid.Cid) (map[string]interface{}, *types.AddressInfo, error) func TestParseCreateExternal(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("CreateExternalExported", expected) + tests, err := tools.LoadTestData[map[string]any](network, "CreateExternalExported", expected) require.NoError(t, err) runTest(t, eam.ParseCreateExternal, tests) } func TestParseCreate(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("CreateExported", expected) + tests, err := tools.LoadTestData[map[string]any](network, "CreateExported", expected) require.NoError(t, err) runTest(t, eam.ParseCreate, tests) } func TestParseCreate2(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("Create2Exported", expected) + tests, err := tools.LoadTestData[map[string]any](network, "Create2Exported", expected) require.NoError(t, err) runTest(t, eam.ParseCreate2, tests) diff --git a/actors/evm/evm_test.go b/actors/evm/evm_test.go index 41a1bd77..bfb2cdba 100644 --- a/actors/evm/evm_test.go +++ b/actors/evm/evm_test.go @@ -16,8 +16,10 @@ import ( //go:embed expected.json var expectedData []byte var expected map[string]any +var network string func TestMain(m *testing.M) { + network = "mainnet" if err := json.Unmarshal(expectedData, &expected); err != nil { panic(err) } @@ -27,35 +29,35 @@ func TestMain(m *testing.M) { type testFn func(network string, height int64, raw []byte) (map[string]interface{}, error) func TestResurrect(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("Resurrect", expected) + tests, err := tools.LoadTestData[map[string]any](network, "Resurrect", expected) require.NoError(t, err) runTest(t, evm.Resurrect, tests) } func TestGetByteCode(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("GetByteCode", expected) + tests, err := tools.LoadTestData[map[string]any](network, "GetByteCode", expected) require.NoError(t, err) runTest(t, evm.GetByteCode, tests) } func TestGetByteCodeHash(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("GetByteCodeHash", expected) + tests, err := tools.LoadTestData[map[string]any](network, "GetByteCodeHash", expected) require.NoError(t, err) runTest(t, evm.GetByteCodeHash, tests) } func TestEVMConstructor(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("EVMConstructor", expected) + tests, err := tools.LoadTestData[map[string]any](network, "EVMConstructor", expected) require.NoError(t, err) runTest(t, evm.EVMConstructor, tests) } func TestGetStorageAt(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("GetStorageAt", expected) + tests, err := tools.LoadTestData[map[string]any](network, "GetStorageAt", expected) require.NoError(t, err) for _, tt := range tests { @@ -76,7 +78,7 @@ func TestGetStorageAt(t *testing.T) { } func TestInvokeContract(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("InvokeContract", expected) + tests, err := tools.LoadTestData[map[string]any](network, "InvokeContract", expected) require.NoError(t, err) for _, tt := range tests { @@ -97,7 +99,7 @@ func TestInvokeContract(t *testing.T) { } func TestInvokeContractDelegate(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("InvokeContractDelegate", expected) + tests, err := tools.LoadTestData[map[string]any](network, "InvokeContractDelegate", expected) require.NoError(t, err) for _, tt := range tests { diff --git a/actors/init/int_test.go b/actors/init/int_test.go index af7e3d37..621649a0 100644 --- a/actors/init/int_test.go +++ b/actors/init/int_test.go @@ -19,7 +19,10 @@ import ( var expectedData []byte var expected map[string]any +var network string + func TestMain(m *testing.M) { + network = "mainnet" if err := json.Unmarshal(expectedData, &expected); err != nil { panic(err) } @@ -29,21 +32,21 @@ func TestMain(m *testing.M) { type testFn func(network string, height int64, msg *parser.LotusMessage, raw []byte) (map[string]interface{}, *types.AddressInfo, error) func TestParseExec(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("ParseExec", expected) + tests, err := tools.LoadTestData[map[string]any](network, "ParseExec", expected) require.NoError(t, err) runTest(t, initActor.ParseExec, tests) } func TestParseExec4(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("ParseExec4", expected) + tests, err := tools.LoadTestData[map[string]any](network, "ParseExec4", expected) require.NoError(t, err) runTest(t, initActor.ParseExec4, tests) } func TestInitConstructor(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("InitConstructor", expected) + tests, err := tools.LoadTestData[map[string]any](network, "InitConstructor", expected) require.NoError(t, err) for _, tt := range tests { diff --git a/actors/market/market_test.go b/actors/market/market_test.go index d9d9d7ca..f1ac4440 100644 --- a/actors/market/market_test.go +++ b/actors/market/market_test.go @@ -17,7 +17,10 @@ import ( var expectedData []byte var expected map[string]any +var network string + func TestMain(m *testing.M) { + network = "mainnet" if err := json.Unmarshal(expectedData, &expected); err != nil { panic(err) } @@ -27,133 +30,133 @@ func TestMain(m *testing.M) { type testFn func(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) func TestPublishStorageDeals(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("PublishStorageDealsParams", expected) + tests, err := tools.LoadTestData[map[string]any](network, "PublishStorageDealsParams", expected) require.NoError(t, err) runTest(t, market.PublishStorageDealsParams, tests) } func TestVerifyDealsForActivation(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("VerifyDealsForActivationParams", expected) + tests, err := tools.LoadTestData[map[string]any](network, "VerifyDealsForActivationParams", expected) require.NoError(t, err) runTest(t, market.VerifyDealsForActivationParams, tests) } func TestActivateDeals(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("ActivateDealsParams", expected) + tests, err := tools.LoadTestData[map[string]any](network, "ActivateDealsParams", expected) require.NoError(t, err) runTest(t, market.ActivateDealsParams, tests) } func TestComputeDataCommitment(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("ComputeDataCommitmentParams", expected) + tests, err := tools.LoadTestData[map[string]any](network, "ComputeDataCommitmentParams", expected) require.NoError(t, err) runTest(t, market.ComputeDataCommitmentParams, tests) } func TestGetBalance(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("GetBalanceParams", expected) + tests, err := tools.LoadTestData[map[string]any](network, "GetBalanceParams", expected) require.NoError(t, err) runTest(t, market.GetBalanceParams, tests) } func TestGetDealDataCommitment(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("GetDealDataCommitmentParams", expected) + tests, err := tools.LoadTestData[map[string]any](network, "GetDealDataCommitmentParams", expected) require.NoError(t, err) runTest(t, market.GetDealDataCommitmentParams, tests) } func TestGetDealClient(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("GetDealClientParams", expected) + tests, err := tools.LoadTestData[map[string]any](network, "GetDealClientParams", expected) require.NoError(t, err) runTest(t, market.GetDealClientParams, tests) } func TestGetDealProvider(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("GetDealProviderParams", expected) + tests, err := tools.LoadTestData[map[string]any](network, "GetDealProviderParams", expected) require.NoError(t, err) runTest(t, market.GetDealProviderParams, tests) } func TestGetDealLabel(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("GetDealLabelParams", expected) + tests, err := tools.LoadTestData[map[string]any](network, "GetDealLabelParams", expected) require.NoError(t, err) runTest(t, market.GetDealLabelParams, tests) } func TestGetDealTerm(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("GetDealTermParams", expected) + tests, err := tools.LoadTestData[map[string]any](network, "GetDealTermParams", expected) require.NoError(t, err) runTest(t, market.GetDealTermParams, tests) } func TestGetDealTotalPrice(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("GetDealTotalPriceParams", expected) + tests, err := tools.LoadTestData[map[string]any](network, "GetDealTotalPriceParams", expected) require.NoError(t, err) runTest(t, market.GetDealTotalPriceParams, tests) } func TestGetDealClientCollateral(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("GetDealClientCollateralParams", expected) + tests, err := tools.LoadTestData[map[string]any](network, "GetDealClientCollateralParams", expected) require.NoError(t, err) runTest(t, market.GetDealClientCollateralParams, tests) } func TestGetDealProviderCollateral(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("GetDealProviderCollateralParams", expected) + tests, err := tools.LoadTestData[map[string]any](network, "GetDealProviderCollateralParams", expected) require.NoError(t, err) runTest(t, market.GetDealProviderCollateralParams, tests) } func TestGetDealVerified(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("GetDealVerifiedParams", expected) + tests, err := tools.LoadTestData[map[string]any](network, "GetDealVerifiedParams", expected) require.NoError(t, err) runTest(t, market.GetDealVerifiedParams, tests) } func TestGetDealActivation(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("GetDealActivationParams", expected) + tests, err := tools.LoadTestData[map[string]any](network, "GetDealActivationParams", expected) require.NoError(t, err) runTest(t, market.GetDealActivationParams, tests) } func TestDealProviderCollateral(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("GetDealProviderCollateralParams", expected) + tests, err := tools.LoadTestData[map[string]any](network, "GetDealProviderCollateralParams", expected) require.NoError(t, err) runTest(t, market.GetDealProviderCollateralParams, tests) } func TestGetDealVerifiedParams(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("GetDealVerifiedParams", expected) + tests, err := tools.LoadTestData[map[string]any](network, "GetDealVerifiedParams", expected) require.NoError(t, err) runTest(t, market.GetDealVerifiedParams, tests) } func TestGetDealActivationParams(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("GetDealActivationParams", expected) + tests, err := tools.LoadTestData[map[string]any](network, "GetDealActivationParams", expected) require.NoError(t, err) runTest(t, market.GetDealActivationParams, tests) } func TestOnMinerSectorsTerminate(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("OnMinerSectorsTerminateParams", expected) + tests, err := tools.LoadTestData[map[string]any](network, "OnMinerSectorsTerminateParams", expected) require.NoError(t, err) for _, tt := range tests { @@ -175,7 +178,7 @@ func TestOnMinerSectorsTerminate(t *testing.T) { } func TestParseAddBalance(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("ParseAddBalance", expected) + tests, err := tools.LoadTestData[map[string]any](network, "ParseAddBalance", expected) require.NoError(t, err) for _, tt := range tests { @@ -197,7 +200,7 @@ func TestParseAddBalance(t *testing.T) { } func TestParseWithdrawBalance(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("ParseWithdrawBalance", expected) + tests, err := tools.LoadTestData[map[string]any](network, "ParseWithdrawBalance", expected) require.NoError(t, err) for _, tt := range tests { diff --git a/actors/miner/address_test.go b/actors/miner/address_test.go index 0d9db678..f911b6f2 100644 --- a/actors/miner/address_test.go +++ b/actors/miner/address_test.go @@ -12,49 +12,49 @@ import ( type testFn func(network string, height int64, rawReturn []byte) (map[string]interface{}, error) func TestChangeMultiaddrs(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("ChangeMultiaddrs", expectedData) + tests, err := tools.LoadTestData[map[string]any](network, "ChangeMultiaddrs", expectedData) require.NoError(t, err) runTest(t, miner.ChangeMultiaddrs, tests) } func TestChangePeerID(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("ChangePeerID", expectedData) + tests, err := tools.LoadTestData[map[string]any](network, "ChangePeerID", expectedData) require.NoError(t, err) runTest(t, miner.ChangePeerID, tests) } func TestChangeWorkerAddress(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("ChangeWorkerAddress", expectedData) + tests, err := tools.LoadTestData[map[string]any](network, "ChangeWorkerAddress", expectedData) require.NoError(t, err) runTest(t, miner.ChangeWorkerAddress, tests) } func TestChangeOwnerAddress(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("ChangeOwnerAddress", expectedData) + tests, err := tools.LoadTestData[map[string]any](network, "ChangeOwnerAddress", expectedData) require.NoError(t, err) runTest(t, miner.ChangeOwnerAddress, tests) } func TestGetOwner(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("GetOwner", expectedData) + tests, err := tools.LoadTestData[map[string]any](network, "GetOwner", expectedData) require.NoError(t, err) runTest(t, miner.GetOwner, tests) } func TestGetPeerID(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("GetPeerID", expectedData) + tests, err := tools.LoadTestData[map[string]any](network, "GetPeerID", expectedData) require.NoError(t, err) runTest(t, miner.GetPeerID, tests) } func TestGetMultiaddrs(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("GetMultiaddrs", expectedData) + tests, err := tools.LoadTestData[map[string]any](network, "GetMultiaddrs", expectedData) require.NoError(t, err) runTest(t, miner.GetMultiaddrs, tests) } func TestIsControllingAddressExported(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("IsControllingAddressExported", expectedData) + tests, err := tools.LoadTestData[map[string]any](network, "IsControllingAddressExported", expectedData) require.NoError(t, err) for _, tt := range tests { diff --git a/actors/miner/balance_test.go b/actors/miner/balance_test.go index cb98218a..a09041ab 100644 --- a/actors/miner/balance_test.go +++ b/actors/miner/balance_test.go @@ -9,19 +9,19 @@ import ( ) func TestGetAvailableBalance(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("GetAvailableBalance", expectedData) + tests, err := tools.LoadTestData[map[string]any](network, "GetAvailableBalance", expectedData) require.NoError(t, err) runTest(t, miner.GetAvailableBalance, tests) } func TestGetVestingFunds(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("GetVestingFunds", expectedData) + tests, err := tools.LoadTestData[map[string]any](network, "GetVestingFunds", expectedData) require.NoError(t, err) runTest(t, miner.GetVestingFunds, tests) } func TestParseWithdrawBalance(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("ParseWithdrawBalance", expectedData) + tests, err := tools.LoadTestData[map[string]any](network, "ParseWithdrawBalance", expectedData) require.NoError(t, err) runTest(t, miner.ParseWithdrawBalance, tests) } diff --git a/actors/miner/miner_test.go b/actors/miner/miner_test.go index 3f9e9a7c..b495886b 100644 --- a/actors/miner/miner_test.go +++ b/actors/miner/miner_test.go @@ -16,7 +16,10 @@ import ( var expected []byte var expectedData map[string]any +var network string + func TestMain(m *testing.M) { + network = "mainnet" if err := json.Unmarshal(expected, &expectedData); err != nil { panic(err) } @@ -24,73 +27,73 @@ func TestMain(m *testing.M) { } func TestDeclareFaults(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("DeclareFaults", expectedData) + tests, err := tools.LoadTestData[map[string]any](network, "DeclareFaults", expectedData) require.NoError(t, err) runTest(t, miner.DeclareFaults, tests) } func TestDeclareFaultsRecovered(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("DeclareFaultsRecovered", expectedData) + tests, err := tools.LoadTestData[map[string]any](network, "DeclareFaultsRecovered", expectedData) require.NoError(t, err) runTest(t, miner.DeclareFaultsRecovered, tests) } func TestProveReplicaUpdates(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("ProveReplicaUpdates", expectedData) + tests, err := tools.LoadTestData[map[string]any](network, "ProveReplicaUpdates", expectedData) require.NoError(t, err) runTest(t, miner.ProveReplicaUpdates, tests) } func TestPreCommitSectorBatch2(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("PreCommitSectorBatch2", expectedData) + tests, err := tools.LoadTestData[map[string]any](network, "PreCommitSectorBatch2", expectedData) require.NoError(t, err) runTest(t, miner.PreCommitSectorBatch2, tests) } func TestProveCommitAggregate(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("ProveCommitAggregate", expectedData) + tests, err := tools.LoadTestData[map[string]any](network, "ProveCommitAggregate", expectedData) require.NoError(t, err) runTest(t, miner.ProveCommitAggregate, tests) } func TestDisputeWindowedPoSt(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("DisputeWindowedPoSt", expectedData) + tests, err := tools.LoadTestData[map[string]any](network, "DisputeWindowedPoSt", expectedData) require.NoError(t, err) runTest(t, miner.DisputeWindowedPoSt, tests) } func TestReportConsensusFault(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("ReportConsensusFault", expectedData) + tests, err := tools.LoadTestData[map[string]any](network, "ReportConsensusFault", expectedData) require.NoError(t, err) runTest(t, miner.ReportConsensusFault, tests) } func TestChangeBeneficiary(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("ChangeBeneficiary", expectedData) + tests, err := tools.LoadTestData[map[string]any](network, "ChangeBeneficiary", expectedData) require.NoError(t, err) runTest(t, miner.ChangeBeneficiary, tests) } func TestMinerConstructor(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("MinerConstructor", expectedData) + tests, err := tools.LoadTestData[map[string]any](network, "MinerConstructor", expectedData) require.NoError(t, err) runTest(t, miner.MinerConstructor, tests) } func TestApplyRewards(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("ApplyRewards", expectedData) + tests, err := tools.LoadTestData[map[string]any](network, "ApplyRewards", expectedData) require.NoError(t, err) runTest(t, miner.ApplyRewards, tests) } func TestOnDeferredCronEvent(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("OnDeferredCronEvent", expectedData) + tests, err := tools.LoadTestData[map[string]any](network, "OnDeferredCronEvent", expectedData) require.NoError(t, err) runTest(t, miner.OnDeferredCronEvent, tests) } func TestTerminateSectors(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("TerminateSectors", expectedData) + tests, err := tools.LoadTestData[map[string]any](network, "TerminateSectors", expectedData) require.NoError(t, err) for _, tt := range tests { @@ -113,7 +116,7 @@ func TestTerminateSectors(t *testing.T) { } func TestProveReplicaUpdates2(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("ProveReplicaUpdates2", expectedData) + tests, err := tools.LoadTestData[map[string]any](network, "ProveReplicaUpdates2", expectedData) require.NoError(t, err) for _, tt := range tests { diff --git a/actors/miner/sector_test.go b/actors/miner/sector_test.go index 24bc7881..beb3b202 100644 --- a/actors/miner/sector_test.go +++ b/actors/miner/sector_test.go @@ -10,73 +10,73 @@ import ( ) func TestExtendSectorExpiration2(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("ExtendSectorExpiration2", expectedData) + tests, err := tools.LoadTestData[map[string]any](network, "ExtendSectorExpiration2", expectedData) require.NoError(t, err) runTest(t, miner.ExtendSectorExpiration2, tests) } func TestPreCommitSector(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("PreCommitSector", expectedData) + tests, err := tools.LoadTestData[map[string]any](network, "PreCommitSector", expectedData) require.NoError(t, err) runTest(t, miner.PreCommitSector, tests) } func TestProveCommitSector(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("ProveCommitSector", expectedData) + tests, err := tools.LoadTestData[map[string]any](network, "ProveCommitSector", expectedData) require.NoError(t, err) runTest(t, miner.ProveCommitSector, tests) } func TestSubmitWindowedPoSt(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("SubmitWindowedPoSt", expectedData) + tests, err := tools.LoadTestData[map[string]any](network, "SubmitWindowedPoSt", expectedData) require.NoError(t, err) runTest(t, miner.SubmitWindowedPoSt, tests) } func TestConfirmSectorProofsValid(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("ConfirmSectorProofsValid", expectedData) + tests, err := tools.LoadTestData[map[string]any](network, "ConfirmSectorProofsValid", expectedData) require.NoError(t, err) runTest(t, miner.ConfirmSectorProofsValid, tests) } func TestCheckSectorProven(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("CheckSectorProven", expectedData) + tests, err := tools.LoadTestData[map[string]any](network, "CheckSectorProven", expectedData) require.NoError(t, err) runTest(t, miner.CheckSectorProven, tests) } func TestExtendSectorExpiration(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("ExtendSectorExpiration", expectedData) + tests, err := tools.LoadTestData[map[string]any](network, "ExtendSectorExpiration", expectedData) require.NoError(t, err) runTest(t, miner.ExtendSectorExpiration, tests) } func TestCompactSectorNumbers(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("CompactSectorNumbers", expectedData) + tests, err := tools.LoadTestData[map[string]any](network, "CompactSectorNumbers", expectedData) require.NoError(t, err) runTest(t, miner.CompactSectorNumbers, tests) } func TestCompactPartitions(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("CompactPartitions", expectedData) + tests, err := tools.LoadTestData[map[string]any](network, "CompactPartitions", expectedData) require.NoError(t, err) runTest(t, miner.CompactPartitions, tests) } func TestPreCommitSectorBatch(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("PreCommitSectorBatch", expectedData) + tests, err := tools.LoadTestData[map[string]any](network, "PreCommitSectorBatch", expectedData) require.NoError(t, err) runTest(t, miner.PreCommitSectorBatch, tests) } func TestGetSectorSize(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("GetSectorSize", expectedData) + tests, err := tools.LoadTestData[map[string]any](network, "GetSectorSize", expectedData) require.NoError(t, err) runTest(t, miner.GetSectorSize, tests) } func TestProveCommitSectors3(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("ProveCommitSectors3", expectedData) + tests, err := tools.LoadTestData[map[string]any](network, "ProveCommitSectors3", expectedData) require.NoError(t, err) for _, tt := range tests { diff --git a/actors/multisig/multisig_test.go b/actors/multisig/multisig_test.go index 1f519ffc..f5fb8a11 100644 --- a/actors/multisig/multisig_test.go +++ b/actors/multisig/multisig_test.go @@ -17,8 +17,10 @@ import ( //go:embed expected.json var expectedData []byte var expected map[string]any +var network string func TestMain(m *testing.M) { + network = "mainnet" if err := json.Unmarshal(expectedData, &expected); err != nil { panic(err) } @@ -28,43 +30,43 @@ func TestMain(m *testing.M) { type testFn func(network string, msg *parser.LotusMessage, height int64, key filTypes.TipSetKey, rawReturn []byte, parser multisig.ParseFn) (map[string]interface{}, error) func TestApprove(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("Approve", expected) + tests, err := tools.LoadTestData[map[string]any](network, "Approve", expected) require.NoError(t, err) runTest(t, multisig.Approve, tests) } func TestCancel(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("Cancel", expected) + tests, err := tools.LoadTestData[map[string]any](network, "Cancel", expected) require.NoError(t, err) runTest(t, multisig.Cancel, tests) } func TestRemoveSigner(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("RemoveSigner", expected) + tests, err := tools.LoadTestData[map[string]any](network, "RemoveSigner", expected) require.NoError(t, err) runTest(t, multisig.RemoveSigner, tests) } func TestChangeNumApprovalsThreshold(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("ChangeNumApprovalsThreshold", expected) + tests, err := tools.LoadTestData[map[string]any](network, "ChangeNumApprovalsThreshold", expected) require.NoError(t, err) runTest(t, multisig.ChangeNumApprovalsThreshold, tests) } func TestLockBalance(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("LockBalance", expected) + tests, err := tools.LoadTestData[map[string]any](network, "LockBalance", expected) require.NoError(t, err) runTest(t, multisig.LockBalance, tests) } func TestUniversalReceiverHook(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("UniversalReceiverHook", expected) + tests, err := tools.LoadTestData[map[string]any](network, "UniversalReceiverHook", expected) require.NoError(t, err) runTest(t, multisig.UniversalReceiverHook, tests) } func TestMsigConstructor(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("MsigConstructor", expected) + tests, err := tools.LoadTestData[map[string]any](network, "MsigConstructor", expected) require.NoError(t, err) for _, tt := range tests { @@ -86,7 +88,7 @@ func TestMsigConstructor(t *testing.T) { } } func TestMsigParams(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("MsigParams", expected) + tests, err := tools.LoadTestData[map[string]any](network, "MsigParams", expected) require.NoError(t, err) for _, tt := range tests { t.Run(tt.Name, func(t *testing.T) { diff --git a/actors/multisig/values_test.go b/actors/multisig/values_test.go index 19009b39..7d5a4a4d 100644 --- a/actors/multisig/values_test.go +++ b/actors/multisig/values_test.go @@ -13,78 +13,78 @@ import ( type valueTestFn func(network string, height int64, txMetadata string) (interface{}, error) func TestChangeOwnerAddressValue(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("ChangeOwnerAddressValue", expected) + tests, err := tools.LoadTestData[map[string]any](network, "ChangeOwnerAddressValue", expected) require.NoError(t, err) runValueTest(t, multisig.ChangeOwnerAddressValue, tests) } func TestParseWithdrawBalanceValue(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("ParseWithdrawBalanceValue", expected) + tests, err := tools.LoadTestData[map[string]any](network, "ParseWithdrawBalanceValue", expected) require.NoError(t, err) runValueTest(t, multisig.ParseWithdrawBalanceValue, tests) } func TestParseInvokeContractValue(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("ParseInvokeContractValue", expected) + tests, err := tools.LoadTestData[map[string]any](network, "ParseInvokeContractValue", expected) require.NoError(t, err) runValueTest(t, multisig.ParseInvokeContractValue, tests) } func TestParseAddSignerValue(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("ParseAddSignerValue", expected) + tests, err := tools.LoadTestData[map[string]any](network, "ParseAddSignerValue", expected) require.NoError(t, err) runValueTest(t, multisig.ParseAddSignerValue, tests) } func TestParseApproveValue(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("ParseApproveValue", expected) + tests, err := tools.LoadTestData[map[string]any](network, "ParseApproveValue", expected) require.NoError(t, err) runValueTest(t, multisig.ParseApproveValue, tests) } func TestParseCancelValue(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("ParseCancelValue", expected) + tests, err := tools.LoadTestData[map[string]any](network, "ParseCancelValue", expected) require.NoError(t, err) runValueTest(t, multisig.ParseCancelValue, tests) } func TestChangeNumApprovalsThresholdValue(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("ChangeNumApprovalsThresholdValue", expected) + tests, err := tools.LoadTestData[map[string]any](network, "ChangeNumApprovalsThresholdValue", expected) require.NoError(t, err) runValueTest(t, multisig.ChangeNumApprovalsThresholdValue, tests) } func TestParseConstructorValue(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("ParseConstructorValue", expected) + tests, err := tools.LoadTestData[map[string]any](network, "ParseConstructorValue", expected) require.NoError(t, err) runValueTest(t, multisig.ParseConstructorValue, tests) } func TestParseLockBalanceValue(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("ParseLockBalanceValue", expected) + tests, err := tools.LoadTestData[map[string]any](network, "ParseLockBalanceValue", expected) require.NoError(t, err) runValueTest(t, multisig.ParseLockBalanceValue, tests) } func TestParseRemoveSignerValue(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("ParseRemoveSignerValue", expected) + tests, err := tools.LoadTestData[map[string]any](network, "ParseRemoveSignerValue", expected) require.NoError(t, err) runValueTest(t, multisig.ParseRemoveSignerValue, tests) } func TestParseSendValue(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("ParseSendValue", expected) + tests, err := tools.LoadTestData[map[string]any](network, "ParseSendValue", expected) require.NoError(t, err) runValueTest(t, multisig.ParseSendValue, tests) } func TestParseSwapSignerValue(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("ParseSwapSignerValue", expected) + tests, err := tools.LoadTestData[map[string]any](network, "ParseSwapSignerValue", expected) require.NoError(t, err) runValueTest(t, multisig.ParseSwapSignerValue, tests) } func TestParseUniversalReceiverHookValue(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("ParseUniversalReceiverHookValue", expected) + tests, err := tools.LoadTestData[map[string]any](network, "ParseUniversalReceiverHookValue", expected) require.NoError(t, err) runValueTest(t, multisig.ParseUniversalReceiverHookValue, tests) } diff --git a/actors/multisig/verifier_test.go b/actors/multisig/verifier_test.go index 790c4e5c..d9518518 100644 --- a/actors/multisig/verifier_test.go +++ b/actors/multisig/verifier_test.go @@ -9,7 +9,7 @@ import ( ) func TestAddVerifierValue(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("AddVerifierValue", expected) + tests, err := tools.LoadTestData[map[string]any](network, "AddVerifierValue", expected) require.NoError(t, err) runValueTest(t, multisig.AddVerifierValue, tests) } diff --git a/actors/paymentChannel/paymentChannel_test.go b/actors/paymentChannel/paymentChannel_test.go index 4b893759..fffcd0dc 100644 --- a/actors/paymentChannel/paymentChannel_test.go +++ b/actors/paymentChannel/paymentChannel_test.go @@ -15,7 +15,10 @@ import ( var expectedData []byte var expected map[string]any +var network string + func TestMain(m *testing.M) { + network = "mainnet" if err := json.Unmarshal(expectedData, &expected); err != nil { panic(err) } @@ -31,13 +34,13 @@ type test struct { } func TestPaymentChannelConstructor(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("PaymentChannelConstructor", expected) + tests, err := tools.LoadTestData[map[string]any](network, "PaymentChannelConstructor", expected) require.NoError(t, err) runTest(t, paymentchannel.PaymentChannelConstructor, tests) } func TestUpdateChannelState(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("UpdateChannelState", expected) + tests, err := tools.LoadTestData[map[string]any](network, "UpdateChannelState", expected) require.NoError(t, err) runTest(t, paymentchannel.UpdateChannelState, tests) } diff --git a/actors/power/power_test.go b/actors/power/power_test.go index 745b2a92..1247e652 100644 --- a/actors/power/power_test.go +++ b/actors/power/power_test.go @@ -16,7 +16,10 @@ import ( var expectedData []byte var expected map[string]any +var network string + func TestMain(m *testing.M) { + network = "mainnet" if err := json.Unmarshal(expectedData, &expected); err != nil { panic(err) } @@ -26,67 +29,67 @@ func TestMain(m *testing.M) { type testFn func(network string, msg *parser.LotusMessage, height int64, raw, rawReturn []byte) (map[string]interface{}, error) func TestCurrentTotalPower(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("CurrentTotalPower", expected) + tests, err := tools.LoadTestData[map[string]any](network, "CurrentTotalPower", expected) require.NoError(t, err) runTest(t, power.CurrentTotalPower, tests) } func TestSubmitPoRepForBulkVerify(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("SubmitPoRepForBulkVerify", expected) + tests, err := tools.LoadTestData[map[string]any](network, "SubmitPoRepForBulkVerify", expected) require.NoError(t, err) runTest(t, power.SubmitPoRepForBulkVerify, tests) } func TestCreateMiner(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("CreateMiner", expected) + tests, err := tools.LoadTestData[map[string]any](network, "CreateMiner", expected) require.NoError(t, err) runTest(t, power.CreateMiner, tests) } func TestEnrollCronEvent(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("EnrollCronEvent", expected) + tests, err := tools.LoadTestData[map[string]any](network, "EnrollCronEvent", expected) require.NoError(t, err) runTest(t, power.EnrollCronEvent, tests) } func TestUpdateClaimedPower(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("UpdateClaimedPower", expected) + tests, err := tools.LoadTestData[map[string]any](network, "UpdateClaimedPower", expected) require.NoError(t, err) runTest(t, power.UpdateClaimedPower, tests) } func TestUpdatePledgeTotal(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("UpdatePledgeTotal", expected) + tests, err := tools.LoadTestData[map[string]any](network, "UpdatePledgeTotal", expected) require.NoError(t, err) runTest(t, power.UpdatePledgeTotal, tests) } func TestNetworkRawPower(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("NetworkRawPower", expected) + tests, err := tools.LoadTestData[map[string]any](network, "NetworkRawPower", expected) require.NoError(t, err) runTest(t, power.NetworkRawPower, tests) } func TestMinerRawPower(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("MinerRawPower", expected) + tests, err := tools.LoadTestData[map[string]any](network, "MinerRawPower", expected) require.NoError(t, err) runTest(t, power.MinerRawPower, tests) } func TestMinerCount(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("MinerCount", expected) + tests, err := tools.LoadTestData[map[string]any](network, "MinerCount", expected) require.NoError(t, err) runTest(t, power.MinerCount, tests) } func TestMinerConsensusCount(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("MinerConsensusCount", expected) + tests, err := tools.LoadTestData[map[string]any](network, "MinerConsensusCount", expected) require.NoError(t, err) runTest(t, power.MinerConsensusCount, tests) } func TestPowerConstructor(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("PowerConstructor", expected) + tests, err := tools.LoadTestData[map[string]any](network, "PowerConstructor", expected) require.NoError(t, err) for _, tt := range tests { diff --git a/actors/reward/reward_test.go b/actors/reward/reward_test.go index 96a9484b..97b8a54d 100644 --- a/actors/reward/reward_test.go +++ b/actors/reward/reward_test.go @@ -15,7 +15,10 @@ import ( var expectedData []byte var expected map[string]any +var network string + func TestMain(m *testing.M) { + network = "mainnet" if err := json.Unmarshal(expectedData, &expected); err != nil { panic(err) } @@ -25,25 +28,25 @@ func TestMain(m *testing.M) { type testFn func(network string, height int64, raw []byte) (map[string]interface{}, error) func TestRewardConstructor(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("RewardConstructor", expected) + tests, err := tools.LoadTestData[map[string]any](network, "RewardConstructor", expected) require.NoError(t, err) runTest(t, reward.RewardConstructor, tests) } func TestAwardBlockReward(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("AwardBlockReward", expected) + tests, err := tools.LoadTestData[map[string]any](network, "AwardBlockReward", expected) require.NoError(t, err) runTest(t, reward.AwardBlockReward, tests) } func TestUpdateNetworkKPI(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("UpdateNetworkKPI", expected) + tests, err := tools.LoadTestData[map[string]any](network, "UpdateNetworkKPI", expected) require.NoError(t, err) runTest(t, reward.UpdateNetworkKPI, tests) } func TestThisEpochReward(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("ThisEpochReward", expected) + tests, err := tools.LoadTestData[map[string]any](network, "ThisEpochReward", expected) require.NoError(t, err) runTest(t, reward.ThisEpochReward, tests) } diff --git a/actors/verifiedRegistry/verifiedRegistry_test.go b/actors/verifiedRegistry/verifiedRegistry_test.go index ccb4ec43..955f828f 100644 --- a/actors/verifiedRegistry/verifiedRegistry_test.go +++ b/actors/verifiedRegistry/verifiedRegistry_test.go @@ -15,7 +15,10 @@ import ( var expectedData []byte var expected map[string]any +var network string + func TestMain(m *testing.M) { + network = "mainnet" if err := json.Unmarshal(expectedData, &expected); err != nil { panic(err) } @@ -26,84 +29,84 @@ type testFn func(network string, height int64, raw []byte) (map[string]interface type testFn2 func(network string, height int64, raw, rawReturn []byte) (map[string]interface{}, error) func TestAddVerifier(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("AddVerifier", expected) + tests, err := tools.LoadTestData[map[string]any](network, "AddVerifier", expected) require.NoError(t, err) runTest(t, verifiedregistry.AddVerifier, tests) } func TestRemoveVerifier(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("RemoveVerifier", expected) + tests, err := tools.LoadTestData[map[string]any](network, "RemoveVerifier", expected) require.NoError(t, err) runTest(t, verifiedregistry.RemoveVerifier, tests) } func TestAddVerifiedClient(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("AddVerifiedClient", expected) + tests, err := tools.LoadTestData[map[string]any](network, "AddVerifiedClient", expected) require.NoError(t, err) runTest(t, verifiedregistry.AddVerifiedClient, tests) } func TestUseBytes(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("UseBytes", expected) + tests, err := tools.LoadTestData[map[string]any](network, "UseBytes", expected) require.NoError(t, err) runTest(t, verifiedregistry.UseBytes, tests) } func TestRestoreBytes(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("RestoreBytes", expected) + tests, err := tools.LoadTestData[map[string]any](network, "RestoreBytes", expected) require.NoError(t, err) runTest(t, verifiedregistry.RestoreBytes, tests) } func TestRemoveVerifiedClientDataCap(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("RemoveVerifiedClientDataCap", expected) + tests, err := tools.LoadTestData[map[string]any](network, "RemoveVerifiedClientDataCap", expected) require.NoError(t, err) runTest(t, verifiedregistry.RemoveVerifiedClientDataCap, tests) } func TestDeprecated1(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("Deprecated1", expected) + tests, err := tools.LoadTestData[map[string]any](network, "Deprecated1", expected) require.NoError(t, err) runTest(t, verifiedregistry.Deprecated1, tests) } func TestDeprecated2(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("Deprecated2", expected) + tests, err := tools.LoadTestData[map[string]any](network, "Deprecated2", expected) require.NoError(t, err) runTest(t, verifiedregistry.Deprecated2, tests) } func TestClaimAllocations(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("ClaimAllocations", expected) + tests, err := tools.LoadTestData[map[string]any](network, "ClaimAllocations", expected) require.NoError(t, err) runTest2(t, verifiedregistry.ClaimAllocations, tests) } func TestGetClaims(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("GetClaims", expected) + tests, err := tools.LoadTestData[map[string]any](network, "GetClaims", expected) require.NoError(t, err) runTest2(t, verifiedregistry.GetClaims, tests) } func TestExtendClaimTerms(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("ExtendClaimTerms", expected) + tests, err := tools.LoadTestData[map[string]any](network, "ExtendClaimTerms", expected) require.NoError(t, err) runTest2(t, verifiedregistry.ExtendClaimTerms, tests) } func TestRemoveExpiredClaims(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("RemoveExpiredClaims", expected) + tests, err := tools.LoadTestData[map[string]any](network, "RemoveExpiredClaims", expected) require.NoError(t, err) runTest2(t, verifiedregistry.RemoveExpiredClaims, tests) } func TestVerifregUniversalReceiverHook(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("VerifregUniversalReceiverHook", expected) + tests, err := tools.LoadTestData[map[string]any](network, "VerifregUniversalReceiverHook", expected) require.NoError(t, err) runTest2(t, verifiedregistry.VerifregUniversalReceiverHook, tests) } func TestRemoveExpiredAllocations(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any]("RemoveExpiredAllocations", expected) + tests, err := tools.LoadTestData[map[string]any](network, "RemoveExpiredAllocations", expected) require.NoError(t, err) runTest2(t, verifiedregistry.RemoveExpiredAllocations, tests) } diff --git a/tools/testutil.go b/tools/testutil.go index c8848a4a..2a781a17 100644 --- a/tools/testutil.go +++ b/tools/testutil.go @@ -168,7 +168,7 @@ type TestCase[T any] struct { Address *types.AddressInfo } -func LoadTestData[T any](fnName string, network string, expected map[string]any) ([]TestCase[T], error) { +func LoadTestData[T any](network string, fnName string, expected map[string]any) ([]TestCase[T], error) { var tests []TestCase[T] for _, version := range GetSupportedVersions(network) { From a2eb7aacf50db8db71f03517b130a2965f4d78d0 Mon Sep 17 00:00:00 2001 From: Eric Mokaya Date: Wed, 22 Jan 2025 22:42:31 +0300 Subject: [PATCH 15/16] fix: add tests --- actors/account/account.go | 27 +++++++---- actors/account/account_test.go | 4 ++ cmd/tracedl/cli.go | 88 ++++++++++++++++++---------------- tools/testutil.go | 42 ++++++++-------- tools/tools_test.go | 24 ++++++++++ tools/version_mapping.go | 15 ++++-- 6 files changed, 127 insertions(+), 73 deletions(-) diff --git a/actors/account/account.go b/actors/account/account.go index 4a397e9d..bb15a9ca 100644 --- a/actors/account/account.go +++ b/actors/account/account.go @@ -9,8 +9,10 @@ import ( accountv10 "github.com/filecoin-project/go-state-types/builtin/v10/account" accountv11 "github.com/filecoin-project/go-state-types/builtin/v11/account" accountv9 "github.com/filecoin-project/go-state-types/builtin/v11/account" + accountv12 "github.com/filecoin-project/go-state-types/builtin/v12/account" + accountv13 "github.com/filecoin-project/go-state-types/builtin/v13/account" accountv14 "github.com/filecoin-project/go-state-types/builtin/v14/account" - accountv15 "github.com/filecoin-project/go-state-types/builtin/v15/account" + typegen "github.com/whyrusleeping/cbor-gen" "github.com/zondax/fil-parser/parser" "github.com/zondax/fil-parser/tools" ) @@ -29,18 +31,25 @@ func PubkeyAddress(network string, raw, rawReturn []byte) (map[string]interface{ } func AuthenticateMessage(network string, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { + versions := tools.GetSupportedVersions(network) + switch { - case tools.V8.IsSupported(network, height): - return nil, fmt.Errorf("not supported") + // all versions before V17 + case tools.AnyIsSupported(network, height, versions[:len(versions)-7]...): + return map[string]interface{}{}, nil // method did not exist case tools.V17.IsSupported(network, height): - return authenticateMessageGeneric[*accountv9.AuthenticateMessageParams, *accountv9.AuthenticateMessageParams](raw, rawReturn, &accountv9.AuthenticateMessageParams{}) + return authenticateMessageGeneric[*accountv9.AuthenticateMessageParams, *typegen.CborBool](raw, rawReturn, &accountv9.AuthenticateMessageParams{}) case tools.V18.IsSupported(network, height): - return authenticateMessageGeneric[*accountv10.AuthenticateMessageParams, *accountv10.AuthenticateMessageParams](raw, rawReturn, &accountv10.AuthenticateMessageParams{}) - case tools.V19.IsSupported(network, height): - return authenticateMessageGeneric[*accountv11.AuthenticateMessageParams, *accountv11.AuthenticateMessageParams](raw, rawReturn, &accountv11.AuthenticateMessageParams{}) + return authenticateMessageGeneric[*accountv10.AuthenticateMessageParams, *typegen.CborBool](raw, rawReturn, &accountv10.AuthenticateMessageParams{}) + case tools.V19.IsSupported(network, height) || tools.V20.IsSupported(network, height): + return authenticateMessageGeneric[*accountv11.AuthenticateMessageParams, *typegen.CborBool](raw, rawReturn, &accountv11.AuthenticateMessageParams{}) + case tools.V21.IsSupported(network, height): + return authenticateMessageGeneric[*accountv12.AuthenticateMessageParams, *typegen.CborBool](raw, rawReturn, &accountv12.AuthenticateMessageParams{}) + case tools.V22.IsSupported(network, height): + return authenticateMessageGeneric[*accountv13.AuthenticateMessageParams, *typegen.CborBool](raw, rawReturn, &accountv13.AuthenticateMessageParams{}) case tools.V23.IsSupported(network, height): - return authenticateMessageGeneric[*accountv14.AuthenticateMessageParams, *accountv14.AuthenticateMessageParams](raw, rawReturn, &accountv14.AuthenticateMessageParams{}) + return authenticateMessageGeneric[*accountv14.AuthenticateMessageParams, *typegen.CborBool](raw, rawReturn, &accountv14.AuthenticateMessageParams{}) default: - return authenticateMessageGeneric[*accountv15.AuthenticateMessageParams, *accountv15.AuthenticateMessageParams](raw, rawReturn, &accountv15.AuthenticateMessageParams{}) + return nil, fmt.Errorf("not supported") } } diff --git a/actors/account/account_test.go b/actors/account/account_test.go index 28136df4..17e80750 100644 --- a/actors/account/account_test.go +++ b/actors/account/account_test.go @@ -3,6 +3,7 @@ package account_test import ( _ "embed" "encoding/json" + "fmt" "os" "testing" @@ -51,6 +52,9 @@ func TestAuthenticateMessage(t *testing.T) { } result, err := account.AuthenticateMessage(tt.Network, tt.Height, trace.Msg.Params, trace.MsgRct.Return) require.NoError(t, err) + data, err := json.Marshal(result) + require.NoError(t, err) + fmt.Println(string(data)) require.True(t, tools.CompareResult(result, tt.Expected)) } }) diff --git a/cmd/tracedl/cli.go b/cmd/tracedl/cli.go index 3b6734ff..ee16a216 100644 --- a/cmd/tracedl/cli.go +++ b/cmd/tracedl/cli.go @@ -28,7 +28,8 @@ func GetStartCommand(c *cli.CLI) *cobra.Command { cmd.Flags().String("type", "traces", "--type trace") cmd.Flags().String("outPath", ".", "--outPath ../") cmd.Flags().String("compress", "gz", "--compress s2") - cmd.Flags().Uint64("height", 0, "--height 387926") + + cmd.Flags().UintSlice("heights", []uint{0}, "--heights 387926,387927,387928") return cmd } @@ -55,57 +56,62 @@ func get(c *cli.CLI, cmd *cobra.Command, _ []string) { zap.S().Errorf("Error loading compress: %s", err) return } - height, err := cmd.Flags().GetUint64("height") - if err != nil { - zap.S().Errorf("Error loading height: %s", err) - return - } - - rpcClient, err := newFilecoinRPCClient(config.NodeURL, config.NodeToken) - if err != nil { - zap.S().Error(err) - return - } - - var data any - switch logType { - case "traces": - data, err = getTraceFileByHeight(height, rpcClient.client) - case "tipset": - data, err = getTipsetFileByHeight(height, lotusChainTypes.EmptyTSK, rpcClient.client) - case "ethlog": - data, err = getEthLogsByHeight(height, rpcClient.client) - case "nativelog": - data, err = getNativeLogsByHeight(height, rpcClient.client) - case "metadata": - data, err = getMetadata(rpcClient) - } + heights, err := cmd.Flags().GetUintSlice("heights") if err != nil { - zap.S().Error(err) + zap.S().Errorf("Error loading heights: %s", err) return } - dataJson, err := sonic.Marshal(data) + rpcClient, err := newFilecoinRPCClient(config.NodeURL, config.NodeToken) if err != nil { zap.S().Error(err) return } + if len(heights) > 0 { + for _, tmp := range heights { + height := uint64(tmp) + var data any + switch logType { + case "traces": + data, err = getTraceFileByHeight(height, rpcClient.client) + case "tipset": + data, err = getTipsetFileByHeight(height, lotusChainTypes.EmptyTSK, rpcClient.client) + case "ethlog": + data, err = getEthLogsByHeight(height, rpcClient.client) + case "nativelog": + data, err = getNativeLogsByHeight(height, rpcClient.client) + case "metadata": + data, err = getMetadata(rpcClient) + } + + if err != nil { + zap.S().Error(err) + return + } + + dataJson, err := sonic.Marshal(data) + if err != nil { + zap.S().Error(err) + return + } + out := dataJson + fname := fmt.Sprintf("%s_%d.json", logType, height) + if format != "" { + out, err = compress(format, dataJson) + if err != nil { + zap.S().Error(err) + return + } + fname = fmt.Sprintf("%s_%d.json.%s", logType, height, format) + } + + if err := writeToFile(outPath, fname, out); err != nil { + zap.S().Error(err) + return + } - out := dataJson - fname := fmt.Sprintf("%s_%d.json", logType, height) - if format != "" { - out, err = compress(format, dataJson) - if err != nil { - zap.S().Error(err) - return } - fname = fmt.Sprintf("%s_%d.json.%s", logType, height, format) - } - - if err := writeToFile(outPath, fname, out); err != nil { - zap.S().Error(err) - return } } diff --git a/tools/testutil.go b/tools/testutil.go index 2a781a17..8299f179 100644 --- a/tools/testutil.go +++ b/tools/testutil.go @@ -8,6 +8,7 @@ import ( "net/http" "os" "reflect" + "strconv" "github.com/bytedance/sonic" "github.com/filecoin-project/lotus/api" @@ -18,7 +19,7 @@ import ( ) const ( - dataPath = "data/heights" + dataPath = "../../data/heights" fileDataExtension = "json.gz" tracesPrefix = "traces" tipsetPrefix = "tipset" @@ -124,28 +125,13 @@ func ReadTraces(height int64) ([]byte, error) { } func ComputeState[T any](height int64, version string) (*T, error) { - tipset, err := ReadTipset(height) - if err != nil { - return nil, err - } - ethlogs, err := ReadEthLogs(height) - if err != nil { - return nil, err - } traces, err := ReadTraces(height) if err != nil { return nil, err } - txsData := types.TxsData{ - EthLogs: ethlogs, - Tipset: tipset, - Traces: traces, - Metadata: types.BlockMetadata{NodeInfo: types.NodeInfo{NodeMajorMinorVersion: version}}, - } - var computeState T - err = sonic.UnmarshalString(string(txsData.Traces), &computeState) + err = sonic.UnmarshalString(string(traces), &computeState) if err != nil { return nil, err } @@ -170,7 +156,8 @@ type TestCase[T any] struct { func LoadTestData[T any](network string, fnName string, expected map[string]any) ([]TestCase[T], error) { var tests []TestCase[T] - for _, version := range GetSupportedVersions(network) { + versions := GetSupportedVersions(network) + for _, version := range versions { versionData := expected[version.String()] if versionData == nil { @@ -186,11 +173,26 @@ func LoadTestData[T any](network string, fnName string, expected map[string]any) return nil, fmt.Errorf("function %s not found in version %s", fnName, version.String()) } + height := version.Height() + if version != version.next() { + height = (version.Height() + version.next().Height()) / 2 + } + if version.Height() == 0 { + height = V8.Height() + } else { + height += 100 + } + + if !version.IsSupported(network, height) { + fmt.Println("skipping", version.String(), height) + continue + } + tests = append(tests, TestCase[T]{ - Name: fnName, + Name: fnName + "_" + version.String() + "_" + strconv.FormatInt(height, 10), Version: version.String(), Url: NodeUrl, - Height: version.Height(), + Height: height, Expected: fnData.(T), }) } diff --git a/tools/tools_test.go b/tools/tools_test.go index 9267f49c..ed76a7a8 100644 --- a/tools/tools_test.go +++ b/tools/tools_test.go @@ -6,6 +6,7 @@ import ( filTypes "github.com/filecoin-project/lotus/chain/types" "github.com/stretchr/testify/require" + typesV2 "github.com/zondax/fil-parser/parser/v2/types" ) func TestBuildTipSetKeyHash(t *testing.T) { @@ -65,6 +66,29 @@ func TestIsSupported(t *testing.T) { } } +func TestDownloadTraces(t *testing.T) { + versions := GetSupportedVersions("mainnet") + + for _, version := range versions { + height := version.Height() + if version != version.next() { + height = (version.Height() + version.next().Height()) / 2 + } + if version.Height() == 0 { + height = V8.Height() + } else { + height += 100 + } + + traces, err := ReadTraces(height) + require.NoError(t, err) + require.NotEmpty(t, traces) + _, err = ComputeState[typesV2.ComputeStateOutputV2](height, version.String()) + require.NoError(t, err) + require.NotEmpty(t, traces) + } +} + /* func TestBuildCidFromMessageTrace(t *testing.T) { h1, err := multihash.Sum([]byte("TEST"), multihash.SHA2_256, -1) diff --git a/tools/version_mapping.go b/tools/version_mapping.go index 114912c0..882ff1f8 100644 --- a/tools/version_mapping.go +++ b/tools/version_mapping.go @@ -11,7 +11,7 @@ type version struct { } var ( - supportedVersions = []version{V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22} + supportedVersions = []version{V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24} V1 version = version{calibration: 0, mainnet: 0, nodeVersion: 1} V2 version = version{calibration: 0, mainnet: 0, nodeVersion: 2} V3 version = version{calibration: 0, mainnet: 0, nodeVersion: 3} @@ -61,9 +61,18 @@ func (v version) IsSupported(network string, height int64) bool { return false } +func AnyIsSupported(network string, height int64, versions ...version) bool { + for _, v := range versions { + if v.IsSupported(network, height) { + return true + } + } + return false +} + func (v version) next() version { for i, version := range supportedVersions { - if version == v { + if version.nodeVersion == v.nodeVersion { if i == len(supportedVersions)-1 { return v } @@ -85,7 +94,7 @@ func (v version) Height() int64 { } func GetSupportedVersions(network string) []version { - result := make([]version, len(supportedVersions)) + var result []version for _, v := range supportedVersions { v.currentNetwork = network result = append(result, v) From 5feb957582970c1a8b25eec4881b373ce5b22a0d Mon Sep 17 00:00:00 2001 From: Eric Mokaya Date: Thu, 23 Jan 2025 12:22:08 +0300 Subject: [PATCH 16/16] test: reduce test repetition --- actors/account/account.go | 10 +- actors/account/account_test.go | 3 + actors/account/expected.json | 81 ++++++++- actors/cron/cron.go | 4 +- actors/cron/cron_test.go | 16 +- actors/datacap/allowance.go | 8 +- actors/datacap/allowance_test.go | 59 ------- actors/datacap/burn.go | 6 +- actors/datacap/burn_test.go | 30 ---- actors/datacap/datacap.go | 8 +- actors/datacap/datacap_test.go | 85 +++++++-- actors/datacap/granularity.go | 2 +- actors/datacap/granularity_test.go | 31 ---- actors/datacap/mint.go | 2 +- actors/datacap/mint_test.go | 17 -- actors/datacap/transfer.go | 2 +- actors/datacap/transfer_test.go | 2 +- actors/eam/create.go | 6 +- actors/eam/eam.go | 2 + actors/eam/{create_test.go => eam_test.go} | 33 ++-- actors/evm/evm.go | 16 +- actors/evm/evm_test.go | 11 +- actors/init/init.go | 8 +- actors/init/int_test.go | 27 +-- actors/market/market.go | 38 ++-- actors/market/market_test.go | 156 ++++------------- actors/miner/address.go | 18 +- actors/miner/address_test.go | 97 ----------- actors/miner/balance.go | 6 +- actors/miner/balance_test.go | 27 --- actors/miner/miner.go | 26 +-- actors/miner/miner_test.go | 162 ++++++++++++------ actors/miner/sector.go | 24 +-- actors/miner/sector_test.go | 99 ----------- actors/multisig/multisig.go | 18 +- actors/multisig/multisig_test.go | 101 +++++++---- actors/multisig/values.go | 26 +-- actors/multisig/values_test.go | 110 ------------ actors/multisig/verifier.go | 2 +- actors/multisig/verifier_test.go | 15 -- actors/paymentChannel/paymentChannel.go | 5 +- actors/paymentChannel/paymentChannel_test.go | 23 +-- actors/power/power.go | 24 +-- actors/power/power_test.go | 80 +++------ actors/reward/reward.go | 10 +- actors/reward/reward_test.go | 37 ++-- actors/verifiedRegistry/verifiedRegistry.go | 30 ++-- .../verifiedRegistry/verifiedRegistry_test.go | 115 ++++--------- cmd/tracedl/cli.go | 75 ++++++-- cmd/tracedl/pkg.go | 126 ++++++++++++++ tools/version_mapping.go | 18 ++ 51 files changed, 855 insertions(+), 1082 deletions(-) delete mode 100644 actors/datacap/allowance_test.go delete mode 100644 actors/datacap/burn_test.go delete mode 100644 actors/datacap/granularity_test.go delete mode 100644 actors/datacap/mint_test.go rename actors/eam/{create_test.go => eam_test.go} (69%) delete mode 100644 actors/miner/address_test.go delete mode 100644 actors/miner/balance_test.go delete mode 100644 actors/miner/sector_test.go delete mode 100644 actors/multisig/values_test.go delete mode 100644 actors/multisig/verifier_test.go create mode 100644 cmd/tracedl/pkg.go diff --git a/actors/account/account.go b/actors/account/account.go index bb15a9ca..81932cde 100644 --- a/actors/account/account.go +++ b/actors/account/account.go @@ -17,7 +17,9 @@ import ( "github.com/zondax/fil-parser/tools" ) -func PubkeyAddress(network string, raw, rawReturn []byte) (map[string]interface{}, error) { +type Account struct{} + +func (a *Account) PubkeyAddress(network string, raw, rawReturn []byte) (map[string]interface{}, error) { metadata := make(map[string]interface{}) metadata[parser.ParamsKey] = base64.StdEncoding.EncodeToString(raw) reader := bytes.NewReader(rawReturn) @@ -30,12 +32,10 @@ func PubkeyAddress(network string, raw, rawReturn []byte) (map[string]interface{ return metadata, nil } -func AuthenticateMessage(network string, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { - versions := tools.GetSupportedVersions(network) - +func (a *Account) AuthenticateMessage(network string, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch { // all versions before V17 - case tools.AnyIsSupported(network, height, versions[:len(versions)-7]...): + case tools.AnyIsSupported(network, height, tools.VersionsBefore(tools.V16)...): return map[string]interface{}{}, nil // method did not exist case tools.V17.IsSupported(network, height): return authenticateMessageGeneric[*accountv9.AuthenticateMessageParams, *typegen.CborBool](raw, rawReturn, &accountv9.AuthenticateMessageParams{}) diff --git a/actors/account/account_test.go b/actors/account/account_test.go index 17e80750..0cdc1561 100644 --- a/actors/account/account_test.go +++ b/actors/account/account_test.go @@ -39,6 +39,7 @@ func TestMain(m *testing.M) { } func TestAuthenticateMessage(t *testing.T) { + tests, err := tools.LoadTestData[map[string]any](network, "AuthenticateMessage", expected) require.NoError(t, err) for _, tt := range tests { @@ -50,6 +51,7 @@ func TestAuthenticateMessage(t *testing.T) { if trace.Msg == nil { continue } + account := &account.Account{} result, err := account.AuthenticateMessage(tt.Network, tt.Height, trace.Msg.Params, trace.MsgRct.Return) require.NoError(t, err) data, err := json.Marshal(result) @@ -74,6 +76,7 @@ func TestPubkeyAddress(t *testing.T) { if trace.Msg == nil { continue } + account := &account.Account{} result, err := account.PubkeyAddress(tt.Network, trace.Msg.Params, trace.MsgRct.Return) require.NoError(t, err) require.True(t, tools.CompareResult(result, tt.Expected)) diff --git a/actors/account/expected.json b/actors/account/expected.json index 625ca337..e8374bce 100644 --- a/actors/account/expected.json +++ b/actors/account/expected.json @@ -1,4 +1,3 @@ - { "V1": { "PubkeyAddress": {}, @@ -15,5 +14,85 @@ "V4": { "PubkeyAddress": {}, "AuthenticateMessage": {} + }, + "V5": { + "PubkeyAddress": {}, + "AuthenticateMessage": {} + }, + "V6": { + "PubkeyAddress": {}, + "AuthenticateMessage": {} + }, + "V7": { + "PubkeyAddress": {}, + "AuthenticateMessage": {} + }, + "V8": { + "PubkeyAddress": {}, + "AuthenticateMessage": {} + }, + "V9": { + "PubkeyAddress": {}, + "AuthenticateMessage": {} + }, + "V10": { + "PubkeyAddress": {}, + "AuthenticateMessage": {} + }, + "V11": { + "PubkeyAddress": {}, + "AuthenticateMessage": {} + }, + "V12": { + "PubkeyAddress": {}, + "AuthenticateMessage": {} + }, + "V13": { + "PubkeyAddress": {}, + "AuthenticateMessage": {} + }, + "V14": { + "PubkeyAddress": {}, + "AuthenticateMessage": {} + }, + "V15": { + "PubkeyAddress": {}, + "AuthenticateMessage": {} + }, + "V16": { + "PubkeyAddress": {}, + "AuthenticateMessage": {} + }, + "V17": { + "PubkeyAddress": {}, + "AuthenticateMessage": {} + }, + "V18": { + "PubkeyAddress": {}, + "AuthenticateMessage": {} + }, + "V19": { + "PubkeyAddress": {}, + "AuthenticateMessage": {} + }, + "V20": { + "PubkeyAddress": {}, + "AuthenticateMessage": {} + }, + "V21": { + "PubkeyAddress": {}, + "AuthenticateMessage": {} + }, + "V22": { + "PubkeyAddress": {}, + "AuthenticateMessage": {} + }, + "V23": { + "PubkeyAddress": {}, + "AuthenticateMessage": {} + }, + "V24": { + "PubkeyAddress": {}, + "AuthenticateMessage": {} } } diff --git a/actors/cron/cron.go b/actors/cron/cron.go index 59d0575b..de236d82 100644 --- a/actors/cron/cron.go +++ b/actors/cron/cron.go @@ -11,7 +11,9 @@ import ( "github.com/zondax/fil-parser/tools" ) -func CronConstructor(network string, height int64, raw []byte) (map[string]interface{}, error) { +type Cron struct{} + +func (c *Cron) CronConstructor(network string, height int64, raw []byte) (map[string]interface{}, error) { switch { case tools.V16.IsSupported(network, height): return cronConstructorGeneric[*cronv8.ConstructorParams](raw, &cronv8.ConstructorParams{}) diff --git a/actors/cron/cron_test.go b/actors/cron/cron_test.go index 646fb58c..5d8082a4 100644 --- a/actors/cron/cron_test.go +++ b/actors/cron/cron_test.go @@ -26,10 +26,18 @@ func TestMain(m *testing.M) { type testFn func(network string, height int64, raw []byte) (map[string]interface{}, error) -func TestCronConstructor(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "CronConstructor", expected) - require.NoError(t, err) - runTest(t, cron.CronConstructor, tests) +func TestCron(t *testing.T) { + cron := &cron.Cron{} + testFns := map[string]testFn{ + "CronConstructor": cron.CronConstructor, + } + for name, fn := range testFns { + t.Run(name, func(t *testing.T) { + tests, err := tools.LoadTestData[map[string]any](network, name, expected) + require.NoError(t, err) + runTest(t, fn, tests) + }) + } } func runTest(t *testing.T, fn testFn, tests []tools.TestCase[map[string]any]) { diff --git a/actors/datacap/allowance.go b/actors/datacap/allowance.go index 68b54032..8ed1bc00 100644 --- a/actors/datacap/allowance.go +++ b/actors/datacap/allowance.go @@ -12,7 +12,7 @@ import ( "github.com/zondax/fil-parser/tools" ) -func IncreaseAllowance(network string, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { +func (*Datacap) IncreaseAllowance(network string, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch { case tools.V8.IsSupported(network, height): return nil, fmt.Errorf("not supported") @@ -32,7 +32,7 @@ func IncreaseAllowance(network string, height int64, raw, rawReturn []byte) (map return nil, fmt.Errorf("not supported") } -func DecreaseAllowance(network string, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { +func (*Datacap) DecreaseAllowance(network string, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch { case tools.V8.IsSupported(network, height): return nil, fmt.Errorf("not supported") @@ -52,7 +52,7 @@ func DecreaseAllowance(network string, height int64, raw, rawReturn []byte) (map return nil, fmt.Errorf("not supported") } -func RevokeAllowance(network string, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { +func (*Datacap) RevokeAllowance(network string, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch { case tools.V8.IsSupported(network, height): return nil, fmt.Errorf("not supported") @@ -72,7 +72,7 @@ func RevokeAllowance(network string, height int64, raw, rawReturn []byte) (map[s return nil, fmt.Errorf("not supported") } -func GetAllowance(network string, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { +func (*Datacap) GetAllowance(network string, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch { case tools.V8.IsSupported(network, height): return nil, fmt.Errorf("not supported") diff --git a/actors/datacap/allowance_test.go b/actors/datacap/allowance_test.go deleted file mode 100644 index 896b03d4..00000000 --- a/actors/datacap/allowance_test.go +++ /dev/null @@ -1,59 +0,0 @@ -package datacap_test - -import ( - "testing" - - "github.com/stretchr/testify/require" - "github.com/zondax/fil-parser/actors/datacap" - "github.com/zondax/fil-parser/tools" - - typesV2 "github.com/zondax/fil-parser/parser/v2/types" -) - -type testFn func(network string, height int64, raw, rawReturn []byte) (map[string]interface{}, error) - -func TestIncreaseAllowance(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "IncreaseAllowance", expected) - require.NoError(t, err) - - runTest(t, datacap.IncreaseAllowance, tests) -} - -func TestDecreaseAllowance(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "DecreaseAllowance", expected) - require.NoError(t, err) - - runTest(t, datacap.DecreaseAllowance, tests) -} - -func TestRevokeAllowance(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "RevokeAllowance", expected) - require.NoError(t, err) - - runTest(t, datacap.RevokeAllowance, tests) -} - -func TestGetAllowance(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "GetAllowance", expected) - require.NoError(t, err) - - runTest(t, datacap.GetAllowance, tests) -} - -func runTest(t *testing.T, fn testFn, tests []tools.TestCase[map[string]any]) { - for _, tt := range tests { - t.Run(tt.Name, func(t *testing.T) { - computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.Height, tt.Version) - require.NoError(t, err) - - for _, trace := range computeState.Trace { - if trace.Msg == nil { - continue - } - result, err := fn(tt.Network, tt.Height, trace.Msg.Params, trace.MsgRct.Return) - require.NoError(t, err) - require.True(t, tools.CompareResult(result, tt.Expected)) - } - }) - } -} diff --git a/actors/datacap/burn.go b/actors/datacap/burn.go index 868f6c5c..26a963f7 100644 --- a/actors/datacap/burn.go +++ b/actors/datacap/burn.go @@ -11,7 +11,7 @@ import ( "github.com/zondax/fil-parser/tools" ) -func BurnExported(network string, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { +func (*Datacap) BurnExported(network string, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch { case tools.V8.IsSupported(network, height): return nil, fmt.Errorf("not supported") @@ -31,7 +31,7 @@ func BurnExported(network string, height int64, raw, rawReturn []byte) (map[stri return nil, fmt.Errorf("not supported") } -func BurnFromExported(network string, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { +func (*Datacap) BurnFromExported(network string, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch { case tools.V8.IsSupported(network, height): return nil, fmt.Errorf("not supported") @@ -51,7 +51,7 @@ func BurnFromExported(network string, height int64, raw, rawReturn []byte) (map[ return nil, fmt.Errorf("not supported") } -func DestroyExported(network string, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { +func (*Datacap) DestroyExported(network string, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch { case tools.V8.IsSupported(network, height): return nil, fmt.Errorf("not supported") diff --git a/actors/datacap/burn_test.go b/actors/datacap/burn_test.go deleted file mode 100644 index a78344dc..00000000 --- a/actors/datacap/burn_test.go +++ /dev/null @@ -1,30 +0,0 @@ -package datacap_test - -import ( - "testing" - - "github.com/stretchr/testify/require" - "github.com/zondax/fil-parser/actors/datacap" - "github.com/zondax/fil-parser/tools" -) - -func TestBurnExported(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "BurnExported", expected) - require.NoError(t, err) - - runTest(t, datacap.BurnExported, tests) -} - -func TestBurnFromExported(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "BurnFromExported", expected) - require.NoError(t, err) - - runTest(t, datacap.BurnFromExported, tests) -} - -func TestDestroyExported(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "DestroyExported", expected) - require.NoError(t, err) - - runTest(t, datacap.DestroyExported, tests) -} diff --git a/actors/datacap/datacap.go b/actors/datacap/datacap.go index 4273955a..316c41bc 100644 --- a/actors/datacap/datacap.go +++ b/actors/datacap/datacap.go @@ -5,7 +5,9 @@ import ( "github.com/zondax/fil-parser/parser" ) -func NameExported(rawReturn []byte) (map[string]interface{}, error) { +type Datacap struct{} + +func (d *Datacap) NameExported(rawReturn []byte) (map[string]interface{}, error) { data, err := parse[*abi.CborString, *abi.CborString](nil, rawReturn, false) if err != nil { return nil, err @@ -14,7 +16,7 @@ func NameExported(rawReturn []byte) (map[string]interface{}, error) { return data, nil } -func SymbolExported(rawReturn []byte) (map[string]interface{}, error) { +func (d *Datacap) SymbolExported(rawReturn []byte) (map[string]interface{}, error) { data, err := parse[*abi.CborString, *abi.CborString](nil, rawReturn, false) if err != nil { return nil, err @@ -23,7 +25,7 @@ func SymbolExported(rawReturn []byte) (map[string]interface{}, error) { return data, nil } -func TotalSupplyExported(rawReturn []byte) (map[string]interface{}, error) { +func (d *Datacap) TotalSupplyExported(rawReturn []byte) (map[string]interface{}, error) { data, err := parse[*abi.TokenAmount, *abi.TokenAmount](nil, rawReturn, false) if err != nil { return nil, err diff --git a/actors/datacap/datacap_test.go b/actors/datacap/datacap_test.go index 404b22cc..dd2800e2 100644 --- a/actors/datacap/datacap_test.go +++ b/actors/datacap/datacap_test.go @@ -12,6 +12,8 @@ import ( "github.com/zondax/fil-parser/tools" ) +type testFn func(network string, height int64, raw, rawReturn []byte) (map[string]interface{}, error) + //go:embed expected.json var expectedData []byte var expected map[string]any @@ -26,25 +28,64 @@ func TestMain(m *testing.M) { os.Exit(m.Run()) } -func TestNameExported(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "NameExported", expected) - require.NoError(t, err) - - runDatacapTest(t, datacap.NameExported, tests) +func TestDatacap(t *testing.T) { + datacap := &datacap.Datacap{} + testFns := map[string]func(rawReturn []byte) (map[string]interface{}, error){ + "NameExported": datacap.NameExported, + "SymbolExported": datacap.SymbolExported, + "TotalSupplyExported": datacap.TotalSupplyExported, + } + for name, fn := range testFns { + t.Run(name, func(t *testing.T) { + tests, err := tools.LoadTestData[map[string]any](network, name, expected) + require.NoError(t, err) + runDatacapTest(t, fn, tests) + }) + } } -func TestSymbolExported(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "SymbolExported", expected) - require.NoError(t, err) - - runDatacapTest(t, datacap.SymbolExported, tests) +func TestBurn(t *testing.T) { + datacap := &datacap.Datacap{} + testFns := map[string]testFn{ + "BurnExported": datacap.BurnExported, + "BurnFromExported": datacap.BurnFromExported, + "DestroyExported": datacap.DestroyExported, + "MintExported": datacap.MintExported, + "TransferExported": datacap.TransferExported, + "IncreaseAllowance": datacap.IncreaseAllowance, + "DecreaseAllowance": datacap.DecreaseAllowance, + "RevokeAllowance": datacap.RevokeAllowance, + "GetAllowance": datacap.GetAllowance, + } + for name, fn := range testFns { + t.Run(name, func(t *testing.T) { + tests, err := tools.LoadTestData[map[string]any](network, name, expected) + require.NoError(t, err) + runTest(t, fn, tests) + }) + } } -func TestTotalSupplyExported(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "TotalSupplyExported", expected) +func TestGranularityExported(t *testing.T) { + tests, err := tools.LoadTestData[map[string]any](network, "GranularityExported", expected) require.NoError(t, err) - runDatacapTest(t, datacap.TotalSupplyExported, tests) + for _, tt := range tests { + t.Run(tt.Name, func(t *testing.T) { + computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.Height, tt.Version) + require.NoError(t, err) + + for _, trace := range computeState.Trace { + if trace.Msg == nil { + continue + } + datacap := &datacap.Datacap{} + result, err := datacap.GranularityExported(tt.Network, tt.Height, trace.MsgRct.Return) + require.NoError(t, err) + require.True(t, tools.CompareResult(result, tt.Expected)) + } + }) + } } func runDatacapTest(t *testing.T, fn func(rawReturn []byte) (map[string]interface{}, error), tests []tools.TestCase[map[string]any]) { @@ -64,3 +105,21 @@ func runDatacapTest(t *testing.T, fn func(rawReturn []byte) (map[string]interfac }) } } + +func runTest(t *testing.T, fn testFn, tests []tools.TestCase[map[string]any]) { + for _, tt := range tests { + t.Run(tt.Name, func(t *testing.T) { + computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.Height, tt.Version) + require.NoError(t, err) + + for _, trace := range computeState.Trace { + if trace.Msg == nil { + continue + } + result, err := fn(tt.Network, tt.Height, trace.Msg.Params, trace.MsgRct.Return) + require.NoError(t, err) + require.True(t, tools.CompareResult(result, tt.Expected)) + } + }) + } +} diff --git a/actors/datacap/granularity.go b/actors/datacap/granularity.go index d15feca9..a2fb7fa8 100644 --- a/actors/datacap/granularity.go +++ b/actors/datacap/granularity.go @@ -12,7 +12,7 @@ import ( "github.com/zondax/fil-parser/tools" ) -func GranularityExported(network string, height int64, rawReturn []byte) (map[string]interface{}, error) { +func (*Datacap) GranularityExported(network string, height int64, rawReturn []byte) (map[string]interface{}, error) { switch { case tools.V8.IsSupported(network, height): return nil, fmt.Errorf("not supported") diff --git a/actors/datacap/granularity_test.go b/actors/datacap/granularity_test.go deleted file mode 100644 index 28c8b9e2..00000000 --- a/actors/datacap/granularity_test.go +++ /dev/null @@ -1,31 +0,0 @@ -package datacap_test - -import ( - "testing" - - "github.com/stretchr/testify/require" - "github.com/zondax/fil-parser/actors/datacap" - typesV2 "github.com/zondax/fil-parser/parser/v2/types" - "github.com/zondax/fil-parser/tools" -) - -func TestGranularityExported(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "GranularityExported", expected) - require.NoError(t, err) - - for _, tt := range tests { - t.Run(tt.Name, func(t *testing.T) { - computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.Height, tt.Version) - require.NoError(t, err) - - for _, trace := range computeState.Trace { - if trace.Msg == nil { - continue - } - result, err := datacap.GranularityExported(tt.Network, tt.Height, trace.MsgRct.Return) - require.NoError(t, err) - require.True(t, tools.CompareResult(result, tt.Expected)) - } - }) - } -} diff --git a/actors/datacap/mint.go b/actors/datacap/mint.go index 781bb024..0bfd85e7 100644 --- a/actors/datacap/mint.go +++ b/actors/datacap/mint.go @@ -17,7 +17,7 @@ type ( mintReturn = unmarshalCBOR ) -func MintExported(network string, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { +func (*Datacap) MintExported(network string, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch { case tools.V8.IsSupported(network, height): return nil, fmt.Errorf("not supported") diff --git a/actors/datacap/mint_test.go b/actors/datacap/mint_test.go deleted file mode 100644 index abc07a31..00000000 --- a/actors/datacap/mint_test.go +++ /dev/null @@ -1,17 +0,0 @@ -package datacap_test - -import ( - "testing" - - "github.com/stretchr/testify/require" - "github.com/zondax/fil-parser/actors/datacap" - "github.com/zondax/fil-parser/tools" -) - -func TestMintExported(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "MintExported", expected) - require.NoError(t, err) - - runTest(t, datacap.MintExported, tests) - -} diff --git a/actors/datacap/transfer.go b/actors/datacap/transfer.go index 13afdd06..54768244 100644 --- a/actors/datacap/transfer.go +++ b/actors/datacap/transfer.go @@ -12,7 +12,7 @@ import ( "github.com/zondax/fil-parser/tools" ) -func TransferExported(network string, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { +func (*Datacap) TransferExported(network string, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch { case tools.V8.IsSupported(network, height): return nil, fmt.Errorf("not supported") diff --git a/actors/datacap/transfer_test.go b/actors/datacap/transfer_test.go index 6d372426..345c5cfa 100644 --- a/actors/datacap/transfer_test.go +++ b/actors/datacap/transfer_test.go @@ -11,6 +11,6 @@ import ( func TestTransferExported(t *testing.T) { tests, err := tools.LoadTestData[map[string]any](network, "TransferExported", expected) require.NoError(t, err) - + datacap := &datacap.Datacap{} runTest(t, datacap.TransferExported, tests) } diff --git a/actors/eam/create.go b/actors/eam/create.go index 88020b9d..3321d2aa 100644 --- a/actors/eam/create.go +++ b/actors/eam/create.go @@ -15,7 +15,7 @@ import ( "github.com/zondax/fil-parser/types" ) -func ParseCreateExternal(network string, height int64, rawParams, rawReturn []byte, msgCid cid.Cid) (map[string]interface{}, *types.AddressInfo, error) { +func (*Eam) ParseCreateExternal(network string, height int64, rawParams, rawReturn []byte, msgCid cid.Cid) (map[string]interface{}, *types.AddressInfo, error) { external := true switch { case tools.V24.IsSupported(network, height): @@ -36,7 +36,7 @@ func ParseCreateExternal(network string, height int64, rawParams, rawReturn []by return nil, nil, fmt.Errorf("unsupported height: %d", height) } -func ParseCreate(network string, height int64, rawParams, rawReturn []byte, msgCid cid.Cid) (map[string]interface{}, *types.AddressInfo, error) { +func (*Eam) ParseCreate(network string, height int64, rawParams, rawReturn []byte, msgCid cid.Cid) (map[string]interface{}, *types.AddressInfo, error) { external := false switch { case tools.V24.IsSupported(network, height): @@ -57,7 +57,7 @@ func ParseCreate(network string, height int64, rawParams, rawReturn []byte, msgC return nil, nil, fmt.Errorf("unsupported height: %d", height) } -func ParseCreate2(network string, height int64, rawParams, rawReturn []byte, msgCid cid.Cid) (map[string]interface{}, *types.AddressInfo, error) { +func (*Eam) ParseCreate2(network string, height int64, rawParams, rawReturn []byte, msgCid cid.Cid) (map[string]interface{}, *types.AddressInfo, error) { external := false switch { case tools.V24.IsSupported(network, height): diff --git a/actors/eam/eam.go b/actors/eam/eam.go index 142de572..34888849 100644 --- a/actors/eam/eam.go +++ b/actors/eam/eam.go @@ -15,6 +15,8 @@ import ( "github.com/zondax/fil-parser/parser" ) +type Eam struct{} + func newEamCreate(r createReturn) parser.EamCreateReturn { switch v := r.(type) { case *eamv15.CreateReturn: diff --git a/actors/eam/create_test.go b/actors/eam/eam_test.go similarity index 69% rename from actors/eam/create_test.go rename to actors/eam/eam_test.go index 97aad8dc..ae08161f 100644 --- a/actors/eam/create_test.go +++ b/actors/eam/eam_test.go @@ -30,25 +30,20 @@ func TestMain(m *testing.M) { type testFn func(network string, height int64, raw, rawReturn []byte, msgCid cid.Cid) (map[string]interface{}, *types.AddressInfo, error) -func TestParseCreateExternal(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "CreateExternalExported", expected) - require.NoError(t, err) - - runTest(t, eam.ParseCreateExternal, tests) -} - -func TestParseCreate(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "CreateExported", expected) - require.NoError(t, err) - - runTest(t, eam.ParseCreate, tests) -} - -func TestParseCreate2(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "Create2Exported", expected) - require.NoError(t, err) - - runTest(t, eam.ParseCreate2, tests) +func TestEam(t *testing.T) { + eam := &eam.Eam{} + testFns := map[string]testFn{ + "ParseCreateExternal": eam.ParseCreateExternal, + "ParseCreate": eam.ParseCreate, + "ParseCreate2": eam.ParseCreate2, + } + for name, fn := range testFns { + t.Run(name, func(t *testing.T) { + tests, err := tools.LoadTestData[map[string]any](network, name, expected) + require.NoError(t, err) + runTest(t, fn, tests) + }) + } } func runTest(t *testing.T, fn testFn, tests []tools.TestCase[map[string]any]) { diff --git a/actors/evm/evm.go b/actors/evm/evm.go index eb2f95d7..af04b726 100644 --- a/actors/evm/evm.go +++ b/actors/evm/evm.go @@ -16,7 +16,9 @@ import ( "github.com/zondax/fil-parser/tools" ) -func InvokeContract(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { +type Evm struct{} + +func (*Evm) InvokeContract(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { metadata := make(map[string]interface{}) reader := bytes.NewReader(rawParams) metadata[parser.ParamsKey] = parser.EthPrefix + hex.EncodeToString(rawParams) @@ -44,7 +46,7 @@ func InvokeContract(network string, height int64, rawParams, rawReturn []byte) ( return metadata, nil } -func Resurrect(network string, height int64, raw []byte) (map[string]interface{}, error) { +func (*Evm) Resurrect(network string, height int64, raw []byte) (map[string]interface{}, error) { switch { case tools.V24.IsSupported(network, height): return parse[*evmv15.ResurrectParams, *evmv15.ResurrectParams](raw, nil, false) @@ -62,7 +64,7 @@ func Resurrect(network string, height int64, raw []byte) (map[string]interface{} return nil, fmt.Errorf("unsupported height: %d", height) } -func InvokeContractDelegate(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { +func (*Evm) InvokeContractDelegate(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { switch { case tools.V24.IsSupported(network, height): return parse[*evmv15.DelegateCallParams, *abi.CborBytes](rawParams, rawReturn, true) @@ -80,7 +82,7 @@ func InvokeContractDelegate(network string, height int64, rawParams, rawReturn [ return nil, fmt.Errorf("unsupported height: %d", height) } -func GetByteCode(network string, height int64, raw []byte) (map[string]interface{}, error) { +func (*Evm) GetByteCode(network string, height int64, raw []byte) (map[string]interface{}, error) { switch { case tools.V24.IsSupported(network, height): data, err := parse[*evmv15.GetBytecodeReturn, *evmv15.GetBytecodeReturn](raw, nil, false) @@ -126,7 +128,7 @@ func GetByteCode(network string, height int64, raw []byte) (map[string]interface return nil, fmt.Errorf("unsupported height: %d", height) } -func GetByteCodeHash(network string, height int64, raw []byte) (map[string]interface{}, error) { +func (*Evm) GetByteCodeHash(network string, height int64, raw []byte) (map[string]interface{}, error) { switch { case tools.V24.IsSupported(network, height): data, err := parse[*abi.CborBytes, *abi.CborBytes](raw, nil, false) @@ -180,7 +182,7 @@ func GetByteCodeHash(network string, height int64, raw []byte) (map[string]inter return nil, fmt.Errorf("unsupported height: %d", height) } -func EVMConstructor(network string, height int64, raw []byte) (map[string]interface{}, error) { +func (*Evm) EVMConstructor(network string, height int64, raw []byte) (map[string]interface{}, error) { switch { case tools.V24.IsSupported(network, height): return parse[*evmv15.ConstructorParams, *evmv15.ConstructorParams](raw, nil, false) @@ -198,7 +200,7 @@ func EVMConstructor(network string, height int64, raw []byte) (map[string]interf return nil, fmt.Errorf("unsupported height: %d", height) } -func GetStorageAt(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { +func (*Evm) GetStorageAt(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { switch { case tools.V24.IsSupported(network, height): return parse[*evmv15.GetStorageAtParams, *abi.CborBytes](rawParams, rawReturn, true) diff --git a/actors/evm/evm_test.go b/actors/evm/evm_test.go index bfb2cdba..f9d3d564 100644 --- a/actors/evm/evm_test.go +++ b/actors/evm/evm_test.go @@ -31,28 +31,28 @@ type testFn func(network string, height int64, raw []byte) (map[string]interface func TestResurrect(t *testing.T) { tests, err := tools.LoadTestData[map[string]any](network, "Resurrect", expected) require.NoError(t, err) - + evm := &evm.Evm{} runTest(t, evm.Resurrect, tests) } func TestGetByteCode(t *testing.T) { tests, err := tools.LoadTestData[map[string]any](network, "GetByteCode", expected) require.NoError(t, err) - + evm := &evm.Evm{} runTest(t, evm.GetByteCode, tests) } func TestGetByteCodeHash(t *testing.T) { tests, err := tools.LoadTestData[map[string]any](network, "GetByteCodeHash", expected) require.NoError(t, err) - + evm := &evm.Evm{} runTest(t, evm.GetByteCodeHash, tests) } func TestEVMConstructor(t *testing.T) { tests, err := tools.LoadTestData[map[string]any](network, "EVMConstructor", expected) require.NoError(t, err) - + evm := &evm.Evm{} runTest(t, evm.EVMConstructor, tests) } @@ -69,6 +69,7 @@ func TestGetStorageAt(t *testing.T) { if trace.Msg == nil { continue } + evm := &evm.Evm{} result, err := evm.GetStorageAt(tt.Network, tt.Height, trace.Msg.Params, trace.MsgRct.Return) require.NoError(t, err) require.True(t, tools.CompareResult(result, tt.Expected)) @@ -90,6 +91,7 @@ func TestInvokeContract(t *testing.T) { if trace.Msg == nil { continue } + evm := &evm.Evm{} result, err := evm.InvokeContract(tt.Network, tt.Height, trace.Msg.Params, trace.MsgRct.Return) require.NoError(t, err) require.True(t, tools.CompareResult(result, tt.Expected)) @@ -111,6 +113,7 @@ func TestInvokeContractDelegate(t *testing.T) { if trace.Msg == nil { continue } + evm := &evm.Evm{} result, err := evm.InvokeContractDelegate(tt.Network, tt.Height, trace.Msg.Params, trace.MsgRct.Return) require.NoError(t, err) require.True(t, tools.CompareResult(result, tt.Expected)) diff --git a/actors/init/init.go b/actors/init/init.go index 44a3c537..1219429d 100644 --- a/actors/init/init.go +++ b/actors/init/init.go @@ -17,7 +17,9 @@ import ( "github.com/zondax/fil-parser/types" ) -func InitConstructor(network string, height int64, raw []byte) (map[string]interface{}, error) { +type Init struct{} + +func (*Init) InitConstructor(network string, height int64, raw []byte) (map[string]interface{}, error) { switch { case tools.V24.IsSupported(network, height): return initConstructor[*builtinInitv15.ConstructorParams](raw) @@ -39,7 +41,7 @@ func InitConstructor(network string, height int64, raw []byte) (map[string]inter return nil, fmt.Errorf("unsupported height: %d", height) } -func ParseExec(network string, height int64, msg *parser.LotusMessage, raw []byte) (map[string]interface{}, *types.AddressInfo, error) { +func (*Init) ParseExec(network string, height int64, msg *parser.LotusMessage, raw []byte) (map[string]interface{}, *types.AddressInfo, error) { switch { case tools.V24.IsSupported(network, height): return parseExec[*builtinInitv15.ExecParams, *builtinInitv15.ExecReturn](msg, raw) @@ -61,7 +63,7 @@ func ParseExec(network string, height int64, msg *parser.LotusMessage, raw []byt return nil, nil, fmt.Errorf("unsupported height: %d", height) } -func ParseExec4(network string, height int64, msg *parser.LotusMessage, raw []byte) (map[string]interface{}, *types.AddressInfo, error) { +func (*Init) ParseExec4(network string, height int64, msg *parser.LotusMessage, raw []byte) (map[string]interface{}, *types.AddressInfo, error) { switch { case tools.V24.IsSupported(network, height): return parseExec[*builtinInitv15.Exec4Params, *builtinInitv15.Exec4Return](msg, raw) diff --git a/actors/init/int_test.go b/actors/init/int_test.go index 621649a0..52791d07 100644 --- a/actors/init/int_test.go +++ b/actors/init/int_test.go @@ -31,18 +31,19 @@ func TestMain(m *testing.M) { type testFn func(network string, height int64, msg *parser.LotusMessage, raw []byte) (map[string]interface{}, *types.AddressInfo, error) -func TestParseExec(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "ParseExec", expected) - require.NoError(t, err) - - runTest(t, initActor.ParseExec, tests) -} - -func TestParseExec4(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "ParseExec4", expected) - require.NoError(t, err) - - runTest(t, initActor.ParseExec4, tests) +func TestInit(t *testing.T) { + initActor := &initActor.Init{} + testFns := map[string]testFn{ + "ParseExec": initActor.ParseExec, + "ParseExec4": initActor.ParseExec4, + } + for name, fn := range testFns { + t.Run(name, func(t *testing.T) { + tests, err := tools.LoadTestData[map[string]any](network, name, expected) + require.NoError(t, err) + runTest(t, fn, tests) + }) + } } func TestInitConstructor(t *testing.T) { @@ -58,7 +59,7 @@ func TestInitConstructor(t *testing.T) { if trace.Msg == nil { continue } - + initActor := &initActor.Init{} result, err := initActor.InitConstructor(tt.Network, tt.Height, trace.Msg.Params) require.NoError(t, err) require.True(t, tools.CompareResult(result, tt.Expected)) diff --git a/actors/market/market.go b/actors/market/market.go index 4899d03f..5526ee97 100644 --- a/actors/market/market.go +++ b/actors/market/market.go @@ -15,7 +15,9 @@ import ( "github.com/zondax/fil-parser/tools" ) -func ParseAddBalance(network string, height int64, rawParams []byte) (map[string]interface{}, error) { +type Market struct{} + +func (*Market) ParseAddBalance(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { case tools.V24.IsSupported(network, height): return parseGeneric[*address.Address, *address.Address](rawParams, nil, false) @@ -33,7 +35,7 @@ func ParseAddBalance(network string, height int64, rawParams []byte) (map[string return nil, fmt.Errorf("unsupported height: %d", height) } -func ParseWithdrawBalance(network string, height int64, rawParams []byte) (map[string]interface{}, error) { +func (*Market) ParseWithdrawBalance(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { case tools.V24.IsSupported(network, height): return parseGeneric[*v15Market.WithdrawBalanceParams, *v15Market.WithdrawBalanceParams](rawParams, nil, false) @@ -55,7 +57,7 @@ func ParseWithdrawBalance(network string, height int64, rawParams []byte) (map[s return nil, fmt.Errorf("unsupported height: %d", height) } -func PublishStorageDealsParams(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { +func (*Market) PublishStorageDealsParams(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { switch { case tools.V24.IsSupported(network, height): return parseGeneric[*v15Market.PublishStorageDealsParams, *v15Market.PublishStorageDealsReturn](rawParams, rawReturn, true) @@ -77,7 +79,7 @@ func PublishStorageDealsParams(network string, height int64, rawParams, rawRetur return nil, fmt.Errorf("unsupported height: %d", height) } -func VerifyDealsForActivationParams(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { +func (*Market) VerifyDealsForActivationParams(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { switch { case tools.V24.IsSupported(network, height): return parseGeneric[*v15Market.VerifyDealsForActivationParams, *v15Market.VerifyDealsForActivationReturn](rawParams, rawReturn, true) @@ -99,7 +101,7 @@ func VerifyDealsForActivationParams(network string, height int64, rawParams, raw return nil, fmt.Errorf("unsupported height: %d", height) } -func ActivateDealsParams(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { +func (*Market) ActivateDealsParams(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { switch { case tools.V24.IsSupported(network, height): return parseGeneric[*v15Market.ActivateDealsParams, *v15Market.ActivateDealsResult](rawParams, rawReturn, true) @@ -119,7 +121,7 @@ func ActivateDealsParams(network string, height int64, rawParams, rawReturn []by return nil, fmt.Errorf("unsupported height: %d", height) } -func OnMinerSectorsTerminateParams(network string, height int64, rawParams []byte) (map[string]interface{}, error) { +func (*Market) OnMinerSectorsTerminateParams(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { case tools.V24.IsSupported(network, height): return parseGeneric[*v15Market.OnMinerSectorsTerminateParams, *v15Market.OnMinerSectorsTerminateParams](rawParams, nil, false) @@ -141,7 +143,7 @@ func OnMinerSectorsTerminateParams(network string, height int64, rawParams []byt return nil, fmt.Errorf("unsupported height: %d", height) } -func ComputeDataCommitmentParams(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { +func (*Market) ComputeDataCommitmentParams(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { switch { case tools.V19.IsSupported(network, height): return parseGeneric[*v11Market.ComputeDataCommitmentParams, *v11Market.ComputeDataCommitmentReturn](rawParams, rawReturn, true) @@ -155,7 +157,7 @@ func ComputeDataCommitmentParams(network string, height int64, rawParams, rawRet return nil, fmt.Errorf("unsupported height: %d", height) } -func GetBalanceParams(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { +func (*Market) GetBalanceParams(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { switch { case tools.V24.IsSupported(network, height): return parseGeneric[*address.Address, *v15Market.GetBalanceReturn](rawParams, rawReturn, true) @@ -173,7 +175,7 @@ func GetBalanceParams(network string, height int64, rawParams, rawReturn []byte) return nil, fmt.Errorf("unsupported height: %d", height) } -func GetDealDataCommitmentParams(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { +func (*Market) GetDealDataCommitmentParams(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { switch { case tools.V24.IsSupported(network, height): return parseGeneric[*v15Market.GetDealDataCommitmentParams, *v15Market.GetDealDataCommitmentReturn](rawParams, rawReturn, true) @@ -191,7 +193,7 @@ func GetDealDataCommitmentParams(network string, height int64, rawParams, rawRet return nil, fmt.Errorf("unsupported height: %d", height) } -func GetDealClientParams(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { +func (*Market) GetDealClientParams(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { switch { case tools.V24.IsSupported(network, height): return parseGeneric[*v15Market.GetDealClientParams, *v15Market.GetDealClientReturn](rawParams, rawReturn, true) @@ -209,7 +211,7 @@ func GetDealClientParams(network string, height int64, rawParams, rawReturn []by return nil, fmt.Errorf("unsupported height: %d", height) } -func GetDealProviderParams(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { +func (*Market) GetDealProviderParams(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { switch { case tools.V24.IsSupported(network, height): return parseGeneric[*v15Market.GetDealProviderParams, *v15Market.GetDealProviderReturn](rawParams, rawReturn, true) @@ -227,7 +229,7 @@ func GetDealProviderParams(network string, height int64, rawParams, rawReturn [] return nil, fmt.Errorf("unsupported height: %d", height) } -func GetDealLabelParams(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { +func (*Market) GetDealLabelParams(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { switch { case tools.V24.IsSupported(network, height): return parseGeneric[*v15Market.GetDealLabelParams, *v15Market.GetDealLabelReturn](rawParams, rawReturn, true) @@ -245,7 +247,7 @@ func GetDealLabelParams(network string, height int64, rawParams, rawReturn []byt return nil, fmt.Errorf("unsupported height: %d", height) } -func GetDealTermParams(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { +func (*Market) GetDealTermParams(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { switch { case tools.V24.IsSupported(network, height): return parseGeneric[*v15Market.GetDealTermParams, *v15Market.GetDealTermReturn](rawParams, rawReturn, true) @@ -263,7 +265,7 @@ func GetDealTermParams(network string, height int64, rawParams, rawReturn []byte return nil, fmt.Errorf("unsupported height: %d", height) } -func GetDealTotalPriceParams(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { +func (*Market) GetDealTotalPriceParams(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { switch { case tools.V24.IsSupported(network, height): return parseGeneric[*v15Market.GetDealTotalPriceParams, *v15Market.GetDealTotalPriceReturn](rawParams, rawReturn, true) @@ -281,7 +283,7 @@ func GetDealTotalPriceParams(network string, height int64, rawParams, rawReturn return nil, fmt.Errorf("unsupported height: %d", height) } -func GetDealClientCollateralParams(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { +func (*Market) GetDealClientCollateralParams(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { switch { case tools.V24.IsSupported(network, height): return parseGeneric[*v15Market.GetDealClientCollateralParams, *v15Market.GetDealClientCollateralReturn](rawParams, rawReturn, true) @@ -299,7 +301,7 @@ func GetDealClientCollateralParams(network string, height int64, rawParams, rawR return nil, fmt.Errorf("unsupported height: %d", height) } -func GetDealProviderCollateralParams(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { +func (*Market) GetDealProviderCollateralParams(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { switch { case tools.V24.IsSupported(network, height): return parseGeneric[*v15Market.GetDealProviderCollateralParams, *v15Market.GetDealProviderCollateralReturn](rawParams, rawReturn, true) @@ -317,7 +319,7 @@ func GetDealProviderCollateralParams(network string, height int64, rawParams, ra return nil, fmt.Errorf("unsupported height: %d", height) } -func GetDealVerifiedParams(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { +func (*Market) GetDealVerifiedParams(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { switch { case tools.V24.IsSupported(network, height): return parseGeneric[*v15Market.GetDealVerifiedParams, *v15Market.GetDealVerifiedReturn](rawParams, rawReturn, true) @@ -335,7 +337,7 @@ func GetDealVerifiedParams(network string, height int64, rawParams, rawReturn [] return nil, fmt.Errorf("unsupported height: %d", height) } -func GetDealActivationParams(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { +func (*Market) GetDealActivationParams(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { switch { case tools.V24.IsSupported(network, height): return parseGeneric[*v15Market.GetDealActivationParams, *v15Market.GetDealActivationReturn](rawParams, rawReturn, true) diff --git a/actors/market/market_test.go b/actors/market/market_test.go index f1ac4440..17e1c6f5 100644 --- a/actors/market/market_test.go +++ b/actors/market/market_test.go @@ -29,130 +29,32 @@ func TestMain(m *testing.M) { type testFn func(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) -func TestPublishStorageDeals(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "PublishStorageDealsParams", expected) - require.NoError(t, err) - - runTest(t, market.PublishStorageDealsParams, tests) -} - -func TestVerifyDealsForActivation(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "VerifyDealsForActivationParams", expected) - require.NoError(t, err) - - runTest(t, market.VerifyDealsForActivationParams, tests) -} - -func TestActivateDeals(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "ActivateDealsParams", expected) - require.NoError(t, err) - - runTest(t, market.ActivateDealsParams, tests) -} - -func TestComputeDataCommitment(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "ComputeDataCommitmentParams", expected) - require.NoError(t, err) - - runTest(t, market.ComputeDataCommitmentParams, tests) -} - -func TestGetBalance(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "GetBalanceParams", expected) - require.NoError(t, err) - - runTest(t, market.GetBalanceParams, tests) -} - -func TestGetDealDataCommitment(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "GetDealDataCommitmentParams", expected) - require.NoError(t, err) - - runTest(t, market.GetDealDataCommitmentParams, tests) -} - -func TestGetDealClient(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "GetDealClientParams", expected) - require.NoError(t, err) - - runTest(t, market.GetDealClientParams, tests) -} - -func TestGetDealProvider(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "GetDealProviderParams", expected) - require.NoError(t, err) - - runTest(t, market.GetDealProviderParams, tests) -} - -func TestGetDealLabel(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "GetDealLabelParams", expected) - require.NoError(t, err) - - runTest(t, market.GetDealLabelParams, tests) -} - -func TestGetDealTerm(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "GetDealTermParams", expected) - require.NoError(t, err) - - runTest(t, market.GetDealTermParams, tests) -} - -func TestGetDealTotalPrice(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "GetDealTotalPriceParams", expected) - require.NoError(t, err) - - runTest(t, market.GetDealTotalPriceParams, tests) -} - -func TestGetDealClientCollateral(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "GetDealClientCollateralParams", expected) - require.NoError(t, err) - - runTest(t, market.GetDealClientCollateralParams, tests) -} - -func TestGetDealProviderCollateral(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "GetDealProviderCollateralParams", expected) - require.NoError(t, err) - - runTest(t, market.GetDealProviderCollateralParams, tests) -} - -func TestGetDealVerified(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "GetDealVerifiedParams", expected) - require.NoError(t, err) - - runTest(t, market.GetDealVerifiedParams, tests) -} - -func TestGetDealActivation(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "GetDealActivationParams", expected) - require.NoError(t, err) - - runTest(t, market.GetDealActivationParams, tests) -} - -func TestDealProviderCollateral(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "GetDealProviderCollateralParams", expected) - require.NoError(t, err) - - runTest(t, market.GetDealProviderCollateralParams, tests) -} - -func TestGetDealVerifiedParams(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "GetDealVerifiedParams", expected) - require.NoError(t, err) - - runTest(t, market.GetDealVerifiedParams, tests) -} - -func TestGetDealActivationParams(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "GetDealActivationParams", expected) - require.NoError(t, err) - - runTest(t, market.GetDealActivationParams, tests) +func TestMarket(t *testing.T) { + market := &market.Market{} + testFns := map[string]testFn{ + "PublishStorageDeals": market.PublishStorageDealsParams, + "VerifyDealsForActivation": market.VerifyDealsForActivationParams, + "ActivateDeals": market.ActivateDealsParams, + "ComputeDataCommitment": market.ComputeDataCommitmentParams, + "GetBalance": market.GetBalanceParams, + "GetDealDataCommitment": market.GetDealDataCommitmentParams, + "GetDealClient": market.GetDealClientParams, + "GetDealProvider": market.GetDealProviderParams, + "GetDealLabel": market.GetDealLabelParams, + "GetDealTerm": market.GetDealTermParams, + "GetDealTotalPrice": market.GetDealTotalPriceParams, + "GetDealClientCollateral": market.GetDealClientCollateralParams, + "GetDealProviderCollateral": market.GetDealProviderCollateralParams, + "GetDealVerified": market.GetDealVerifiedParams, + "GetDealActivation": market.GetDealActivationParams, + } + for name, fn := range testFns { + t.Run(name, func(t *testing.T) { + tests, err := tools.LoadTestData[map[string]any](network, name, expected) + require.NoError(t, err) + runTest(t, fn, tests) + }) + } } func TestOnMinerSectorsTerminate(t *testing.T) { @@ -168,7 +70,7 @@ func TestOnMinerSectorsTerminate(t *testing.T) { if trace.Msg == nil { continue } - + market := &market.Market{} result, err := market.OnMinerSectorsTerminateParams(tt.Network, tt.Height, trace.Msg.Params) require.NoError(t, err) require.True(t, tools.CompareResult(result, tt.Expected)) @@ -190,7 +92,7 @@ func TestParseAddBalance(t *testing.T) { if trace.Msg == nil { continue } - + market := &market.Market{} result, err := market.ParseAddBalance(tt.Network, tt.Height, trace.Msg.Params) require.NoError(t, err) require.True(t, tools.CompareResult(result, tt.Expected)) @@ -212,7 +114,7 @@ func TestParseWithdrawBalance(t *testing.T) { if trace.Msg == nil { continue } - + market := &market.Market{} result, err := market.ParseWithdrawBalance(tt.Network, tt.Height, trace.Msg.Params) require.NoError(t, err) require.True(t, tools.CompareResult(result, tt.Expected)) diff --git a/actors/miner/address.go b/actors/miner/address.go index 985a47bb..60611891 100644 --- a/actors/miner/address.go +++ b/actors/miner/address.go @@ -15,7 +15,9 @@ import ( "github.com/zondax/fil-parser/tools" ) -func ChangeMultiaddrs(network string, height int64, rawParams []byte) (map[string]interface{}, error) { +type Miner struct{} + +func (*Miner) ChangeMultiaddrs(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { case tools.V24.IsSupported(network, height): return parseGeneric[*miner15.ChangeMultiaddrsParams, *miner15.ChangeMultiaddrsParams](rawParams, nil, false) @@ -37,7 +39,7 @@ func ChangeMultiaddrs(network string, height int64, rawParams []byte) (map[strin return nil, fmt.Errorf("unsupported height: %d", height) } -func ChangePeerID(network string, height int64, rawParams []byte) (map[string]interface{}, error) { +func (*Miner) ChangePeerID(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { case tools.V24.IsSupported(network, height): return parseGeneric[*miner15.ChangePeerIDParams, *miner15.ChangePeerIDParams](rawParams, nil, false) @@ -59,7 +61,7 @@ func ChangePeerID(network string, height int64, rawParams []byte) (map[string]in return nil, fmt.Errorf("unsupported height: %d", height) } -func ChangeWorkerAddress(network string, height int64, rawParams []byte) (map[string]interface{}, error) { +func (*Miner) ChangeWorkerAddress(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { case tools.V24.IsSupported(network, height): return parseGeneric[*miner15.ChangeWorkerAddressParams, *miner15.ChangeWorkerAddressParams](rawParams, nil, false) @@ -81,7 +83,7 @@ func ChangeWorkerAddress(network string, height int64, rawParams []byte) (map[st return nil, fmt.Errorf("unsupported height: %d", height) } -func ChangeOwnerAddress(network string, height int64, rawParams []byte) (map[string]interface{}, error) { +func (*Miner) ChangeOwnerAddress(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { case tools.V24.IsSupported(network, height): return parseGeneric[*address.Address, *address.Address](rawParams, nil, false) @@ -103,7 +105,7 @@ func ChangeOwnerAddress(network string, height int64, rawParams []byte) (map[str return nil, fmt.Errorf("unsupported height: %d", height) } -func IsControllingAddressExported(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { +func (*Miner) IsControllingAddressExported(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { switch { case tools.V24.IsSupported(network, height): return parseGeneric[*miner15.IsControllingAddressParams, *miner15.IsControllingAddressReturn](rawParams, rawReturn, true) @@ -125,7 +127,7 @@ func IsControllingAddressExported(network string, height int64, rawParams, rawRe return nil, fmt.Errorf("unsupported height: %d", height) } -func GetOwner(network string, height int64, rawReturn []byte) (map[string]interface{}, error) { +func (*Miner) GetOwner(network string, height int64, rawReturn []byte) (map[string]interface{}, error) { switch { case tools.V24.IsSupported(network, height): return parseGeneric[*miner15.GetOwnerReturn, *miner15.GetOwnerReturn](rawReturn, nil, false) @@ -147,7 +149,7 @@ func GetOwner(network string, height int64, rawReturn []byte) (map[string]interf return nil, fmt.Errorf("unsupported height: %d", height) } -func GetPeerID(network string, height int64, rawReturn []byte) (map[string]interface{}, error) { +func (*Miner) GetPeerID(network string, height int64, rawReturn []byte) (map[string]interface{}, error) { switch { case tools.V24.IsSupported(network, height): return parseGeneric[*miner15.GetPeerIDReturn, *miner15.GetPeerIDReturn](rawReturn, nil, false) @@ -169,7 +171,7 @@ func GetPeerID(network string, height int64, rawReturn []byte) (map[string]inter return nil, fmt.Errorf("unsupported height: %d", height) } -func GetMultiaddrs(network string, height int64, rawReturn []byte) (map[string]interface{}, error) { +func (*Miner) GetMultiaddrs(network string, height int64, rawReturn []byte) (map[string]interface{}, error) { switch { case tools.V24.IsSupported(network, height): return parseGeneric[*miner15.GetMultiAddrsReturn, *miner15.GetMultiAddrsReturn](rawReturn, nil, false) diff --git a/actors/miner/address_test.go b/actors/miner/address_test.go deleted file mode 100644 index f911b6f2..00000000 --- a/actors/miner/address_test.go +++ /dev/null @@ -1,97 +0,0 @@ -package miner_test - -import ( - "testing" - - "github.com/stretchr/testify/require" - "github.com/zondax/fil-parser/actors/miner" - typesV2 "github.com/zondax/fil-parser/parser/v2/types" - "github.com/zondax/fil-parser/tools" -) - -type testFn func(network string, height int64, rawReturn []byte) (map[string]interface{}, error) - -func TestChangeMultiaddrs(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "ChangeMultiaddrs", expectedData) - require.NoError(t, err) - runTest(t, miner.ChangeMultiaddrs, tests) -} - -func TestChangePeerID(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "ChangePeerID", expectedData) - require.NoError(t, err) - runTest(t, miner.ChangePeerID, tests) -} - -func TestChangeWorkerAddress(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "ChangeWorkerAddress", expectedData) - require.NoError(t, err) - runTest(t, miner.ChangeWorkerAddress, tests) -} - -func TestChangeOwnerAddress(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "ChangeOwnerAddress", expectedData) - require.NoError(t, err) - runTest(t, miner.ChangeOwnerAddress, tests) -} - -func TestGetOwner(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "GetOwner", expectedData) - require.NoError(t, err) - runTest(t, miner.GetOwner, tests) -} - -func TestGetPeerID(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "GetPeerID", expectedData) - require.NoError(t, err) - runTest(t, miner.GetPeerID, tests) -} - -func TestGetMultiaddrs(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "GetMultiaddrs", expectedData) - require.NoError(t, err) - runTest(t, miner.GetMultiaddrs, tests) -} - -func TestIsControllingAddressExported(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "IsControllingAddressExported", expectedData) - require.NoError(t, err) - - for _, tt := range tests { - t.Run(tt.Name, func(t *testing.T) { - computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.Height, tt.Version) - require.NoError(t, err) - - for _, trace := range computeState.Trace { - if trace.Msg == nil { - continue - } - - result, err := miner.IsControllingAddressExported(tt.Network, tt.Height, trace.Msg.Params, trace.MsgRct.Return) - require.NoError(t, err) - require.True(t, tools.CompareResult(result, tt.Expected)) - - } - }) - } -} - -func runTest(t *testing.T, fn testFn, tests []tools.TestCase[map[string]any]) { - for _, tt := range tests { - t.Run(tt.Name, func(t *testing.T) { - computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.Height, tt.Version) - require.NoError(t, err) - - for _, trace := range computeState.Trace { - if trace.Msg == nil { - continue - } - - result, err := fn(tt.Network, tt.Height, trace.MsgRct.Return) - require.NoError(t, err) - require.True(t, tools.CompareResult(result, tt.Expected)) - - } - }) - } -} diff --git a/actors/miner/balance.go b/actors/miner/balance.go index b83362cc..4efebd73 100644 --- a/actors/miner/balance.go +++ b/actors/miner/balance.go @@ -14,7 +14,7 @@ import ( "github.com/zondax/fil-parser/tools" ) -func GetAvailableBalance(network string, height int64, rawReturn []byte) (map[string]interface{}, error) { +func (*Miner) GetAvailableBalance(network string, height int64, rawReturn []byte) (map[string]interface{}, error) { switch { case tools.V24.IsSupported(network, height): return parseGeneric[*miner15.GetAvailableBalanceReturn, *miner15.GetAvailableBalanceReturn](rawReturn, nil, false) @@ -36,7 +36,7 @@ func GetAvailableBalance(network string, height int64, rawReturn []byte) (map[st return nil, fmt.Errorf("unsupported height: %d", height) } -func GetVestingFunds(network string, height int64, rawReturn []byte) (map[string]interface{}, error) { +func (*Miner) GetVestingFunds(network string, height int64, rawReturn []byte) (map[string]interface{}, error) { switch { case tools.V24.IsSupported(network, height): return parseGeneric[*miner15.GetVestingFundsReturn, *miner15.GetVestingFundsReturn](rawReturn, nil, false) @@ -58,7 +58,7 @@ func GetVestingFunds(network string, height int64, rawReturn []byte) (map[string return nil, fmt.Errorf("unsupported height: %d", height) } -func ParseWithdrawBalance(network string, height int64, rawParams []byte) (map[string]interface{}, error) { +func (*Miner) ParseWithdrawBalance(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { case tools.V24.IsSupported(network, height): return parseGeneric[*miner15.WithdrawBalanceParams, *miner15.WithdrawBalanceParams](rawParams, nil, false) diff --git a/actors/miner/balance_test.go b/actors/miner/balance_test.go deleted file mode 100644 index a09041ab..00000000 --- a/actors/miner/balance_test.go +++ /dev/null @@ -1,27 +0,0 @@ -package miner_test - -import ( - "testing" - - "github.com/stretchr/testify/require" - "github.com/zondax/fil-parser/actors/miner" - "github.com/zondax/fil-parser/tools" -) - -func TestGetAvailableBalance(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "GetAvailableBalance", expectedData) - require.NoError(t, err) - runTest(t, miner.GetAvailableBalance, tests) -} - -func TestGetVestingFunds(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "GetVestingFunds", expectedData) - require.NoError(t, err) - runTest(t, miner.GetVestingFunds, tests) -} - -func TestParseWithdrawBalance(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "ParseWithdrawBalance", expectedData) - require.NoError(t, err) - runTest(t, miner.ParseWithdrawBalance, tests) -} diff --git a/actors/miner/miner.go b/actors/miner/miner.go index 9fa67ace..10a2b78e 100644 --- a/actors/miner/miner.go +++ b/actors/miner/miner.go @@ -14,7 +14,7 @@ import ( "github.com/zondax/fil-parser/tools" ) -func TerminateSectors(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { +func (*Miner) TerminateSectors(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { switch { case tools.V24.IsSupported(network, height): return parseGeneric[*miner15.TerminateSectorsParams, *miner15.TerminateSectorsReturn](rawParams, rawReturn, true) @@ -36,7 +36,7 @@ func TerminateSectors(network string, height int64, rawParams, rawReturn []byte) return nil, fmt.Errorf("unsupported height: %d", height) } -func DeclareFaults(network string, height int64, rawParams []byte) (map[string]interface{}, error) { +func (*Miner) DeclareFaults(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { case tools.V24.IsSupported(network, height): return parseGeneric[*miner15.DeclareFaultsParams, *miner15.DeclareFaultsParams](rawParams, nil, false) @@ -58,7 +58,7 @@ func DeclareFaults(network string, height int64, rawParams []byte) (map[string]i return nil, fmt.Errorf("unsupported height: %d", height) } -func DeclareFaultsRecovered(network string, height int64, rawParams []byte) (map[string]interface{}, error) { +func (*Miner) DeclareFaultsRecovered(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { case tools.V24.IsSupported(network, height): return parseGeneric[*miner15.DeclareFaultsRecoveredParams, *miner15.DeclareFaultsRecoveredParams](rawParams, nil, false) @@ -80,7 +80,7 @@ func DeclareFaultsRecovered(network string, height int64, rawParams []byte) (map return nil, fmt.Errorf("unsupported height: %d", height) } -func ProveReplicaUpdates(network string, height int64, rawParams []byte) (map[string]interface{}, error) { +func (*Miner) ProveReplicaUpdates(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { case tools.V24.IsSupported(network, height): return parseGeneric[*miner15.ProveReplicaUpdatesParams, *miner15.ProveReplicaUpdatesParams](rawParams, nil, false) @@ -102,7 +102,7 @@ func ProveReplicaUpdates(network string, height int64, rawParams []byte) (map[st return nil, fmt.Errorf("unsupported height: %d", height) } -func PreCommitSectorBatch2(network string, height int64, rawParams []byte) (map[string]interface{}, error) { +func (*Miner) PreCommitSectorBatch2(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { case tools.V24.IsSupported(network, height): return parseGeneric[*miner15.PreCommitSectorBatchParams2, *miner15.PreCommitSectorBatchParams2](rawParams, nil, false) @@ -124,7 +124,7 @@ func PreCommitSectorBatch2(network string, height int64, rawParams []byte) (map[ return nil, fmt.Errorf("unsupported height: %d", height) } -func ProveReplicaUpdates2(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { +func (*Miner) ProveReplicaUpdates2(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { switch { case tools.V24.IsSupported(network, height): return parseGeneric[*miner15.ProveReplicaUpdatesParams2, *miner15.ProveReplicaUpdatesParams2](rawParams, rawReturn, true) @@ -146,7 +146,7 @@ func ProveReplicaUpdates2(network string, height int64, rawParams, rawReturn []b return nil, fmt.Errorf("unsupported height: %d", height) } -func ProveCommitAggregate(network string, height int64, rawParams []byte) (map[string]interface{}, error) { +func (*Miner) ProveCommitAggregate(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { case tools.V24.IsSupported(network, height): return parseGeneric[*miner15.ProveCommitAggregateParams, *miner15.ProveCommitAggregateParams](rawParams, nil, false) @@ -168,7 +168,7 @@ func ProveCommitAggregate(network string, height int64, rawParams []byte) (map[s return nil, fmt.Errorf("unsupported height: %d", height) } -func DisputeWindowedPoSt(network string, height int64, rawParams []byte) (map[string]interface{}, error) { +func (*Miner) DisputeWindowedPoSt(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { case tools.V24.IsSupported(network, height): return parseGeneric[*miner15.DisputeWindowedPoStParams, *miner15.DisputeWindowedPoStParams](rawParams, nil, false) @@ -190,7 +190,7 @@ func DisputeWindowedPoSt(network string, height int64, rawParams []byte) (map[st return nil, fmt.Errorf("unsupported height: %d", height) } -func ReportConsensusFault(network string, height int64, rawParams []byte) (map[string]interface{}, error) { +func (*Miner) ReportConsensusFault(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { case tools.V24.IsSupported(network, height): return parseGeneric[*miner15.ReportConsensusFaultParams, *miner15.ReportConsensusFaultParams](rawParams, nil, false) @@ -212,7 +212,7 @@ func ReportConsensusFault(network string, height int64, rawParams []byte) (map[s return nil, fmt.Errorf("unsupported height: %d", height) } -func ChangeBeneficiary(network string, height int64, rawParams []byte) (map[string]interface{}, error) { +func (*Miner) ChangeBeneficiary(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { case tools.V24.IsSupported(network, height): return parseGeneric[*miner15.ChangeBeneficiaryParams, *miner15.ChangeBeneficiaryParams](rawParams, nil, false) @@ -234,7 +234,7 @@ func ChangeBeneficiary(network string, height int64, rawParams []byte) (map[stri return nil, fmt.Errorf("unsupported height: %d", height) } -func MinerConstructor(network string, height int64, rawParams []byte) (map[string]interface{}, error) { +func (*Miner) MinerConstructor(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { case tools.V24.IsSupported(network, height): return parseGeneric[*miner15.MinerConstructorParams, *miner15.MinerConstructorParams](rawParams, nil, false) @@ -256,7 +256,7 @@ func MinerConstructor(network string, height int64, rawParams []byte) (map[strin return nil, fmt.Errorf("unsupported height: %d", height) } -func ApplyRewards(network string, height int64, rawParams []byte) (map[string]interface{}, error) { +func (*Miner) ApplyRewards(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { case tools.V24.IsSupported(network, height): return parseGeneric[*miner15.ApplyRewardParams, *miner15.ApplyRewardParams](rawParams, nil, false) @@ -278,7 +278,7 @@ func ApplyRewards(network string, height int64, rawParams []byte) (map[string]in return nil, fmt.Errorf("unsupported height: %d", height) } -func OnDeferredCronEvent(network string, height int64, rawParams []byte) (map[string]interface{}, error) { +func (*Miner) OnDeferredCronEvent(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { case tools.V24.IsSupported(network, height): return parseGeneric[*miner15.DeferredCronEventParams, *miner15.DeferredCronEventParams](rawParams, nil, false) diff --git a/actors/miner/miner_test.go b/actors/miner/miner_test.go index b495886b..10a0aaf8 100644 --- a/actors/miner/miner_test.go +++ b/actors/miner/miner_test.go @@ -12,6 +12,8 @@ import ( "github.com/zondax/fil-parser/tools" ) +type testFn func(network string, height int64, rawReturn []byte) (map[string]interface{}, error) + //go:embed expected.json var expected []byte var expectedData map[string]any @@ -26,76 +28,122 @@ func TestMain(m *testing.M) { os.Exit(m.Run()) } -func TestDeclareFaults(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "DeclareFaults", expectedData) - require.NoError(t, err) - runTest(t, miner.DeclareFaults, tests) +func TestMiner(t *testing.T) { + miner := &miner.Miner{} + testFns := map[string]testFn{ + "DeclareFaults": miner.DeclareFaults, + "DeclareFaultsRecovered": miner.DeclareFaultsRecovered, + "ProveReplicaUpdates": miner.ProveReplicaUpdates, + "PreCommitSectorBatch2": miner.PreCommitSectorBatch2, + "ProveCommitAggregate": miner.ProveCommitAggregate, + "DisputeWindowedPoSt": miner.DisputeWindowedPoSt, + "ReportConsensusFault": miner.ReportConsensusFault, + "ChangeBeneficiary": miner.ChangeBeneficiary, + "MinerConstructor": miner.MinerConstructor, + "ApplyRewards": miner.ApplyRewards, + "OnDeferredCronEvent": miner.OnDeferredCronEvent, + "ChangeMultiaddrs": miner.ChangeMultiaddrs, + "ChangePeerID": miner.ChangePeerID, + "ChangeWorkerAddress": miner.ChangeWorkerAddress, + "ChangeOwnerAddress": miner.ChangeOwnerAddress, + "GetOwner": miner.GetOwner, + "GetPeerID": miner.GetPeerID, + "GetMultiaddrs": miner.GetMultiaddrs, + "GetAvailableBalance": miner.GetAvailableBalance, + "GetVestingFunds": miner.GetVestingFunds, + "ParseWithdrawBalance": miner.ParseWithdrawBalance, + "ExtendSectorExpiration2": miner.ExtendSectorExpiration2, + "PreCommitSector": miner.PreCommitSector, + "ProveCommitSector": miner.ProveCommitSector, + "SubmitWindowedPoSt": miner.SubmitWindowedPoSt, + "ConfirmSectorProofsValid": miner.ConfirmSectorProofsValid, + "CheckSectorProven": miner.CheckSectorProven, + "ExtendSectorExpiration": miner.ExtendSectorExpiration, + "CompactSectorNumbers": miner.CompactSectorNumbers, + "CompactPartitions": miner.CompactPartitions, + "PreCommitSectorBatch": miner.PreCommitSectorBatch, + "GetSectorSize": miner.GetSectorSize, + } + for name, fn := range testFns { + t.Run(name, func(t *testing.T) { + tests, err := tools.LoadTestData[map[string]any](network, name, expectedData) + require.NoError(t, err) + runTest(t, fn, tests) + }) + } } -func TestDeclareFaultsRecovered(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "DeclareFaultsRecovered", expectedData) +func TestTerminateSectors(t *testing.T) { + tests, err := tools.LoadTestData[map[string]any](network, "TerminateSectors", expectedData) require.NoError(t, err) - runTest(t, miner.DeclareFaultsRecovered, tests) -} -func TestProveReplicaUpdates(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "ProveReplicaUpdates", expectedData) - require.NoError(t, err) - runTest(t, miner.ProveReplicaUpdates, tests) -} + for _, tt := range tests { + t.Run(tt.Name, func(t *testing.T) { + computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.Height, tt.Version) + require.NoError(t, err) -func TestPreCommitSectorBatch2(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "PreCommitSectorBatch2", expectedData) - require.NoError(t, err) - runTest(t, miner.PreCommitSectorBatch2, tests) -} + for _, trace := range computeState.Trace { + if trace.Msg == nil { + continue + } + miner := &miner.Miner{} + result, err := miner.TerminateSectors(tt.Network, tt.Height, trace.Msg.Params, trace.MsgRct.Return) + require.NoError(t, err) + require.True(t, tools.CompareResult(result, tt.Expected)) -func TestProveCommitAggregate(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "ProveCommitAggregate", expectedData) - require.NoError(t, err) - runTest(t, miner.ProveCommitAggregate, tests) + } + }) + } } -func TestDisputeWindowedPoSt(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "DisputeWindowedPoSt", expectedData) +func TestProveReplicaUpdates2(t *testing.T) { + tests, err := tools.LoadTestData[map[string]any](network, "ProveReplicaUpdates2", expectedData) require.NoError(t, err) - runTest(t, miner.DisputeWindowedPoSt, tests) -} -func TestReportConsensusFault(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "ReportConsensusFault", expectedData) - require.NoError(t, err) - runTest(t, miner.ReportConsensusFault, tests) -} + for _, tt := range tests { + t.Run(tt.Name, func(t *testing.T) { + computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.Height, tt.Version) + require.NoError(t, err) -func TestChangeBeneficiary(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "ChangeBeneficiary", expectedData) - require.NoError(t, err) - runTest(t, miner.ChangeBeneficiary, tests) -} + for _, trace := range computeState.Trace { + if trace.Msg == nil { + continue + } -func TestMinerConstructor(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "MinerConstructor", expectedData) - require.NoError(t, err) - runTest(t, miner.MinerConstructor, tests) -} + miner := &miner.Miner{} + result, err := miner.ProveReplicaUpdates2(tt.Network, tt.Height, trace.Msg.Params, trace.MsgRct.Return) + require.NoError(t, err) + require.True(t, tools.CompareResult(result, tt.Expected)) -func TestApplyRewards(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "ApplyRewards", expectedData) - require.NoError(t, err) - runTest(t, miner.ApplyRewards, tests) + } + }) + } } -func TestOnDeferredCronEvent(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "OnDeferredCronEvent", expectedData) +func TestIsControllingAddressExported(t *testing.T) { + tests, err := tools.LoadTestData[map[string]any](network, "IsControllingAddressExported", expectedData) require.NoError(t, err) - runTest(t, miner.OnDeferredCronEvent, tests) -} -func TestTerminateSectors(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "TerminateSectors", expectedData) - require.NoError(t, err) + for _, tt := range tests { + t.Run(tt.Name, func(t *testing.T) { + computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.Height, tt.Version) + require.NoError(t, err) + + for _, trace := range computeState.Trace { + if trace.Msg == nil { + continue + } + miner := &miner.Miner{} + result, err := miner.IsControllingAddressExported(tt.Network, tt.Height, trace.Msg.Params, trace.MsgRct.Return) + require.NoError(t, err) + require.True(t, tools.CompareResult(result, tt.Expected)) + } + }) + } +} + +func runTest(t *testing.T, fn testFn, tests []tools.TestCase[map[string]any]) { for _, tt := range tests { t.Run(tt.Name, func(t *testing.T) { computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.Height, tt.Version) @@ -106,7 +154,7 @@ func TestTerminateSectors(t *testing.T) { continue } - result, err := miner.TerminateSectors(tt.Network, tt.Height, trace.Msg.Params, trace.MsgRct.Return) + result, err := fn(tt.Network, tt.Height, trace.MsgRct.Return) require.NoError(t, err) require.True(t, tools.CompareResult(result, tt.Expected)) @@ -115,8 +163,8 @@ func TestTerminateSectors(t *testing.T) { } } -func TestProveReplicaUpdates2(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "ProveReplicaUpdates2", expectedData) +func TestProveCommitSectors3(t *testing.T) { + tests, err := tools.LoadTestData[map[string]any](network, "ProveCommitSectors3", expectedData) require.NoError(t, err) for _, tt := range tests { @@ -128,8 +176,8 @@ func TestProveReplicaUpdates2(t *testing.T) { if trace.Msg == nil { continue } - - result, err := miner.ProveReplicaUpdates2(tt.Network, tt.Height, trace.Msg.Params, trace.MsgRct.Return) + miner := &miner.Miner{} + result, err := miner.ProveCommitSectors3(tt.Network, tt.Height, trace.Msg.Params, trace.MsgRct.Return) require.NoError(t, err) require.True(t, tools.CompareResult(result, tt.Expected)) diff --git a/actors/miner/sector.go b/actors/miner/sector.go index 2e46261c..b724bcef 100644 --- a/actors/miner/sector.go +++ b/actors/miner/sector.go @@ -14,7 +14,7 @@ import ( "github.com/zondax/fil-parser/tools" ) -func ExtendSectorExpiration2(network string, height int64, rawParams []byte) (map[string]interface{}, error) { +func (*Miner) ExtendSectorExpiration2(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { case tools.V24.IsSupported(network, height): return parseGeneric[*miner15.ExtendSectorExpiration2Params, *miner15.ExtendSectorExpiration2Params](rawParams, nil, false) @@ -36,7 +36,7 @@ func ExtendSectorExpiration2(network string, height int64, rawParams []byte) (ma return nil, fmt.Errorf("unsupported height: %d", height) } -func PreCommitSector(network string, height int64, rawParams []byte) (map[string]interface{}, error) { +func (*Miner) PreCommitSector(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { case tools.V24.IsSupported(network, height): return parseGeneric[*miner15.PreCommitSectorParams, *miner15.PreCommitSectorParams](rawParams, nil, false) @@ -58,7 +58,7 @@ func PreCommitSector(network string, height int64, rawParams []byte) (map[string return nil, fmt.Errorf("unsupported height: %d", height) } -func ProveCommitSector(network string, height int64, rawParams []byte) (map[string]interface{}, error) { +func (*Miner) ProveCommitSector(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { case tools.V24.IsSupported(network, height): return parseGeneric[*miner15.ProveCommitSectorParams, *miner15.ProveCommitSectorParams](rawParams, nil, false) @@ -80,7 +80,7 @@ func ProveCommitSector(network string, height int64, rawParams []byte) (map[stri return nil, fmt.Errorf("unsupported height: %d", height) } -func ProveCommitSectors3(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { +func (*Miner) ProveCommitSectors3(network string, height int64, rawParams, rawReturn []byte) (map[string]interface{}, error) { switch { case tools.V24.IsSupported(network, height): return parseGeneric[*miner15.ProveCommitSectors3Params, *miner15.ProveCommitSectors3Return](rawParams, rawReturn, true) @@ -102,7 +102,7 @@ func ProveCommitSectors3(network string, height int64, rawParams, rawReturn []by return nil, fmt.Errorf("unsupported height: %d", height) } -func SubmitWindowedPoSt(network string, height int64, rawParams []byte) (map[string]interface{}, error) { +func (*Miner) SubmitWindowedPoSt(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { case tools.V24.IsSupported(network, height): return parseGeneric[*miner15.SubmitWindowedPoStParams, *miner15.SubmitWindowedPoStParams](rawParams, nil, false) @@ -124,7 +124,7 @@ func SubmitWindowedPoSt(network string, height int64, rawParams []byte) (map[str return nil, fmt.Errorf("unsupported height: %d", height) } -func ConfirmSectorProofsValid(network string, height int64, rawParams []byte) (map[string]interface{}, error) { +func (*Miner) ConfirmSectorProofsValid(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { case tools.V24.IsSupported(network, height): return nil, fmt.Errorf("not supported") @@ -146,7 +146,7 @@ func ConfirmSectorProofsValid(network string, height int64, rawParams []byte) (m return nil, fmt.Errorf("unsupported height: %d", height) } -func CheckSectorProven(network string, height int64, rawParams []byte) (map[string]interface{}, error) { +func (*Miner) CheckSectorProven(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { case tools.V24.IsSupported(network, height): return parseGeneric[*miner15.CheckSectorProvenParams, *miner15.CheckSectorProvenParams](rawParams, nil, false) @@ -168,7 +168,7 @@ func CheckSectorProven(network string, height int64, rawParams []byte) (map[stri return nil, fmt.Errorf("unsupported height: %d", height) } -func ExtendSectorExpiration(network string, height int64, rawParams []byte) (map[string]interface{}, error) { +func (*Miner) ExtendSectorExpiration(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { case tools.V24.IsSupported(network, height): return parseGeneric[*miner15.ExtendSectorExpirationParams, *miner15.ExtendSectorExpirationParams](rawParams, nil, false) @@ -190,7 +190,7 @@ func ExtendSectorExpiration(network string, height int64, rawParams []byte) (map return nil, fmt.Errorf("unsupported height: %d", height) } -func CompactSectorNumbers(network string, height int64, rawParams []byte) (map[string]interface{}, error) { +func (*Miner) CompactSectorNumbers(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { case tools.V24.IsSupported(network, height): return parseGeneric[*miner15.CompactSectorNumbersParams, *miner15.CompactSectorNumbersParams](rawParams, nil, false) @@ -212,7 +212,7 @@ func CompactSectorNumbers(network string, height int64, rawParams []byte) (map[s return nil, fmt.Errorf("unsupported height: %d", height) } -func CompactPartitions(network string, height int64, rawParams []byte) (map[string]interface{}, error) { +func (*Miner) CompactPartitions(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { case tools.V24.IsSupported(network, height): return parseGeneric[*miner15.CompactPartitionsParams, *miner15.CompactPartitionsParams](rawParams, nil, false) @@ -234,7 +234,7 @@ func CompactPartitions(network string, height int64, rawParams []byte) (map[stri return nil, fmt.Errorf("unsupported height: %d", height) } -func PreCommitSectorBatch(network string, height int64, rawParams []byte) (map[string]interface{}, error) { +func (*Miner) PreCommitSectorBatch(network string, height int64, rawParams []byte) (map[string]interface{}, error) { switch { case tools.V24.IsSupported(network, height): return parseGeneric[*miner15.PreCommitSectorBatchParams, *miner15.PreCommitSectorBatchParams](rawParams, nil, false) @@ -256,6 +256,6 @@ func PreCommitSectorBatch(network string, height int64, rawParams []byte) (map[s return nil, fmt.Errorf("unsupported height: %d", height) } -func GetSectorSize(network string, height int64, rawReturn []byte) (map[string]interface{}, error) { +func (*Miner) GetSectorSize(network string, height int64, rawReturn []byte) (map[string]interface{}, error) { return nil, fmt.Errorf("unsupported height: %d", height) } diff --git a/actors/miner/sector_test.go b/actors/miner/sector_test.go deleted file mode 100644 index beb3b202..00000000 --- a/actors/miner/sector_test.go +++ /dev/null @@ -1,99 +0,0 @@ -package miner_test - -import ( - "testing" - - "github.com/stretchr/testify/require" - "github.com/zondax/fil-parser/actors/miner" - typesV2 "github.com/zondax/fil-parser/parser/v2/types" - "github.com/zondax/fil-parser/tools" -) - -func TestExtendSectorExpiration2(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "ExtendSectorExpiration2", expectedData) - require.NoError(t, err) - runTest(t, miner.ExtendSectorExpiration2, tests) -} - -func TestPreCommitSector(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "PreCommitSector", expectedData) - require.NoError(t, err) - runTest(t, miner.PreCommitSector, tests) -} - -func TestProveCommitSector(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "ProveCommitSector", expectedData) - require.NoError(t, err) - runTest(t, miner.ProveCommitSector, tests) -} - -func TestSubmitWindowedPoSt(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "SubmitWindowedPoSt", expectedData) - require.NoError(t, err) - runTest(t, miner.SubmitWindowedPoSt, tests) -} - -func TestConfirmSectorProofsValid(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "ConfirmSectorProofsValid", expectedData) - require.NoError(t, err) - runTest(t, miner.ConfirmSectorProofsValid, tests) -} - -func TestCheckSectorProven(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "CheckSectorProven", expectedData) - require.NoError(t, err) - runTest(t, miner.CheckSectorProven, tests) -} - -func TestExtendSectorExpiration(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "ExtendSectorExpiration", expectedData) - require.NoError(t, err) - runTest(t, miner.ExtendSectorExpiration, tests) -} - -func TestCompactSectorNumbers(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "CompactSectorNumbers", expectedData) - require.NoError(t, err) - runTest(t, miner.CompactSectorNumbers, tests) -} - -func TestCompactPartitions(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "CompactPartitions", expectedData) - require.NoError(t, err) - runTest(t, miner.CompactPartitions, tests) -} - -func TestPreCommitSectorBatch(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "PreCommitSectorBatch", expectedData) - require.NoError(t, err) - runTest(t, miner.PreCommitSectorBatch, tests) -} - -func TestGetSectorSize(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "GetSectorSize", expectedData) - require.NoError(t, err) - runTest(t, miner.GetSectorSize, tests) -} - -func TestProveCommitSectors3(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "ProveCommitSectors3", expectedData) - require.NoError(t, err) - - for _, tt := range tests { - t.Run(tt.Name, func(t *testing.T) { - computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.Height, tt.Version) - require.NoError(t, err) - - for _, trace := range computeState.Trace { - if trace.Msg == nil { - continue - } - - result, err := miner.ProveCommitSectors3(tt.Network, tt.Height, trace.Msg.Params, trace.MsgRct.Return) - require.NoError(t, err) - require.True(t, tools.CompareResult(result, tt.Expected)) - - } - }) - } -} diff --git a/actors/multisig/multisig.go b/actors/multisig/multisig.go index 8b2ac703..f7149334 100644 --- a/actors/multisig/multisig.go +++ b/actors/multisig/multisig.go @@ -17,7 +17,9 @@ import ( "github.com/zondax/fil-parser/tools" ) -func MsigConstructor(network string, height int64, raw []byte) (map[string]interface{}, error) { +type Msig struct{} + +func (*Msig) MsigConstructor(network string, height int64, raw []byte) (map[string]interface{}, error) { switch { case tools.V16.IsSupported(network, height): return parse[*multisig8.ConstructorParams, []byte](raw, cborUnmarshaller[*multisig8.ConstructorParams]) @@ -39,7 +41,7 @@ func MsigConstructor(network string, height int64, raw []byte) (map[string]inter return map[string]interface{}{}, nil } -func MsigParams(network string, msg *parser.LotusMessage, height int64, key filTypes.TipSetKey, parser ParseFn) (map[string]interface{}, error) { +func (*Msig) MsigParams(network string, msg *parser.LotusMessage, height int64, key filTypes.TipSetKey, parser ParseFn) (map[string]interface{}, error) { switch { case tools.V16.IsSupported(network, height): return parseWithMsigParser[*multisig8.ConstructorParams, *multisig8.ConstructorParams](msg, height, key, parser, nil, jsonUnmarshaller[*multisig8.ConstructorParams], false) @@ -61,7 +63,7 @@ func MsigParams(network string, msg *parser.LotusMessage, height int64, key filT return map[string]interface{}{}, nil } -func Approve(network string, msg *parser.LotusMessage, height int64, key filTypes.TipSetKey, rawReturn []byte, parser ParseFn) (map[string]interface{}, error) { +func (*Msig) Approve(network string, msg *parser.LotusMessage, height int64, key filTypes.TipSetKey, rawReturn []byte, parser ParseFn) (map[string]interface{}, error) { switch { case tools.V16.IsSupported(network, height): return parseWithMsigParser[*multisig8.ApproveReturn, *multisig8.ApproveReturn](msg, height, key, parser, rawReturn, cborUnmarshaller[*multisig8.ApproveReturn], true) @@ -83,7 +85,7 @@ func Approve(network string, msg *parser.LotusMessage, height int64, key filType return map[string]interface{}{}, nil } -func Cancel(network string, msg *parser.LotusMessage, height int64, key filTypes.TipSetKey, rawReturn []byte, parser ParseFn) (map[string]interface{}, error) { +func (*Msig) Cancel(network string, msg *parser.LotusMessage, height int64, key filTypes.TipSetKey, rawReturn []byte, parser ParseFn) (map[string]interface{}, error) { switch { case tools.V16.IsSupported(network, height): return parseWithMsigParser[metadataWithCbor, metadataWithCbor](msg, height, key, parser, rawReturn, noopUnmarshaller[metadataWithCbor], false) @@ -105,7 +107,7 @@ func Cancel(network string, msg *parser.LotusMessage, height int64, key filTypes return map[string]interface{}{}, nil } -func RemoveSigner(network string, msg *parser.LotusMessage, height int64, key filTypes.TipSetKey, rawReturn []byte, parser ParseFn) (map[string]interface{}, error) { +func (*Msig) RemoveSigner(network string, msg *parser.LotusMessage, height int64, key filTypes.TipSetKey, rawReturn []byte, parser ParseFn) (map[string]interface{}, error) { switch { case tools.V16.IsSupported(network, height): return parseWithMsigParser[metadataWithCbor, metadataWithCbor](msg, height, key, parser, rawReturn, noopUnmarshaller[metadataWithCbor], false) @@ -127,7 +129,7 @@ func RemoveSigner(network string, msg *parser.LotusMessage, height int64, key fi return map[string]interface{}{}, nil } -func ChangeNumApprovalsThreshold(network string, msg *parser.LotusMessage, height int64, key filTypes.TipSetKey, rawReturn []byte, parser ParseFn) (map[string]interface{}, error) { +func (*Msig) ChangeNumApprovalsThreshold(network string, msg *parser.LotusMessage, height int64, key filTypes.TipSetKey, rawReturn []byte, parser ParseFn) (map[string]interface{}, error) { switch { case tools.V16.IsSupported(network, height): return parse[*multisig8.ChangeNumApprovalsThresholdParams, []byte](rawReturn, cborUnmarshaller[*multisig8.ChangeNumApprovalsThresholdParams]) @@ -149,7 +151,7 @@ func ChangeNumApprovalsThreshold(network string, msg *parser.LotusMessage, heigh return map[string]interface{}{}, nil } -func LockBalance(network string, msg *parser.LotusMessage, height int64, key filTypes.TipSetKey, rawReturn []byte, parser ParseFn) (map[string]interface{}, error) { +func (*Msig) LockBalance(network string, msg *parser.LotusMessage, height int64, key filTypes.TipSetKey, rawReturn []byte, parser ParseFn) (map[string]interface{}, error) { switch { case tools.V16.IsSupported(network, height): return parse[*multisig8.LockBalanceParams, []byte](rawReturn, cborUnmarshaller[*multisig8.LockBalanceParams]) @@ -171,7 +173,7 @@ func LockBalance(network string, msg *parser.LotusMessage, height int64, key fil return map[string]interface{}{}, nil } -func UniversalReceiverHook(network string, msg *parser.LotusMessage, height int64, key filTypes.TipSetKey, rawReturn []byte, parser ParseFn) (map[string]interface{}, error) { +func (*Msig) UniversalReceiverHook(network string, msg *parser.LotusMessage, height int64, key filTypes.TipSetKey, rawReturn []byte, parser ParseFn) (map[string]interface{}, error) { switch { case tools.V16.IsSupported(network, height): return parse[*abi.CborBytesTransparent, []byte](rawReturn, cborUnmarshaller[*abi.CborBytesTransparent]) diff --git a/actors/multisig/multisig_test.go b/actors/multisig/multisig_test.go index f5fb8a11..7a715bc5 100644 --- a/actors/multisig/multisig_test.go +++ b/actors/multisig/multisig_test.go @@ -3,6 +3,7 @@ package multisig_test import ( _ "embed" "encoding/json" + "reflect" "testing" filTypes "github.com/filecoin-project/lotus/chain/types" @@ -14,6 +15,9 @@ import ( typesV2 "github.com/zondax/fil-parser/parser/v2/types" ) +type testFn func(network string, msg *parser.LotusMessage, height int64, key filTypes.TipSetKey, rawReturn []byte, parser multisig.ParseFn) (map[string]interface{}, error) +type valueTestFn func(network string, height int64, txMetadata string) (interface{}, error) + //go:embed expected.json var expectedData []byte var expected map[string]any @@ -27,42 +31,52 @@ func TestMain(m *testing.M) { m.Run() } -type testFn func(network string, msg *parser.LotusMessage, height int64, key filTypes.TipSetKey, rawReturn []byte, parser multisig.ParseFn) (map[string]interface{}, error) - -func TestApprove(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "Approve", expected) - require.NoError(t, err) - runTest(t, multisig.Approve, tests) -} - -func TestCancel(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "Cancel", expected) - require.NoError(t, err) - runTest(t, multisig.Cancel, tests) -} - -func TestRemoveSigner(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "RemoveSigner", expected) - require.NoError(t, err) - runTest(t, multisig.RemoveSigner, tests) +func TestMsig(t *testing.T) { + multisig := &multisig.Msig{} + testFns := map[string]testFn{ + "Approve": multisig.Approve, + "Cancel": multisig.Cancel, + "RemoveSigner": multisig.RemoveSigner, + "ChangeNumApprovalsThreshold": multisig.ChangeNumApprovalsThreshold, + "LockBalance": multisig.LockBalance, + "UniversalReceiverHook": multisig.UniversalReceiverHook, + } + for name, fn := range testFns { + t.Run(name, func(t *testing.T) { + tests, err := tools.LoadTestData[map[string]any](network, name, expected) + require.NoError(t, err) + runTest(t, fn, tests) + }) + } } -func TestChangeNumApprovalsThreshold(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "ChangeNumApprovalsThreshold", expected) - require.NoError(t, err) - runTest(t, multisig.ChangeNumApprovalsThreshold, tests) -} +func TestValues(t *testing.T) { + multisig := &multisig.Msig{} + testFns := map[string]valueTestFn{ + "ChangeOwnerAddressValue": multisig.ChangeOwnerAddressValue, + "ParseWithdrawBalanceValue": multisig.ParseWithdrawBalanceValue, + "ParseInvokeContractValue": multisig.ParseInvokeContractValue, + "ParseAddSignerValue": multisig.ParseAddSignerValue, + "ParseApproveValue": multisig.ParseApproveValue, + "ParseCancelValue": multisig.ParseCancelValue, + "ChangeNumApprovalsThresholdValue": multisig.ChangeNumApprovalsThresholdValue, + "ParseConstructorValue": multisig.ParseConstructorValue, + "ParseLockBalanceValue": multisig.ParseLockBalanceValue, + "ParseRemoveSignerValue": multisig.ParseRemoveSignerValue, + "ParseSendValue": multisig.ParseSendValue, + "ParseSwapSignerValue": multisig.ParseSwapSignerValue, + "ParseUniversalReceiverHookValue": multisig.ParseUniversalReceiverHookValue, + "AddVerifierValue": multisig.AddVerifierValue, + } -func TestLockBalance(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "LockBalance", expected) - require.NoError(t, err) - runTest(t, multisig.LockBalance, tests) -} + for name, fn := range testFns { + t.Run(name, func(t *testing.T) { + tests, err := tools.LoadTestData[map[string]any](network, name, expected) + require.NoError(t, err) + runValueTest(t, fn, tests) + }) + } -func TestUniversalReceiverHook(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "UniversalReceiverHook", expected) - require.NoError(t, err) - runTest(t, multisig.UniversalReceiverHook, tests) } func TestMsigConstructor(t *testing.T) { @@ -78,7 +92,7 @@ func TestMsigConstructor(t *testing.T) { if trace.Msg == nil { continue } - + multisig := &multisig.Msig{} result, err := multisig.MsigConstructor(tt.Network, tt.Height, trace.MsgRct.Return) require.NoError(t, err) require.True(t, tools.CompareResult(result, tt.Expected)) @@ -105,6 +119,7 @@ func TestMsigParams(t *testing.T) { From: trace.Msg.From, Method: trace.Msg.Method, } + multisig := &multisig.Msig{} result, err := multisig.MsigParams(tt.Network, lotusMsg, tt.Height, tt.TipsetKey, func(*parser.LotusMessage, int64, filTypes.TipSetKey) (string, error) { return "", nil }) @@ -142,3 +157,23 @@ func runTest(t *testing.T, fn testFn, tests []tools.TestCase[map[string]any]) { }) } } + +func runValueTest(t *testing.T, fn valueTestFn, tests []tools.TestCase[map[string]any]) { + for _, tt := range tests { + t.Run(tt.Name, func(t *testing.T) { + computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.Height, tt.Version) + require.NoError(t, err) + + for _, trace := range computeState.Trace { + if trace.Msg == nil { + continue + } + // TODO: parse whole multisig tx first before calling this function + + result, err := fn(tt.Network, tt.Height, string(trace.Msg.Params)) + require.NoError(t, err) + require.True(t, reflect.DeepEqual(result, tt.Expected)) + } + }) + } +} diff --git a/actors/multisig/values.go b/actors/multisig/values.go index 412d46a4..816dd808 100644 --- a/actors/multisig/values.go +++ b/actors/multisig/values.go @@ -15,7 +15,7 @@ import ( "github.com/zondax/fil-parser/tools" ) -func ChangeOwnerAddressValue(network string, height int64, txMetadata string) (interface{}, error) { +func (*Msig) ChangeOwnerAddressValue(network string, height int64, txMetadata string) (interface{}, error) { switch { case tools.V16.IsSupported(network, height): return parse[*ChangeOwnerAddressParams, string](txMetadata, jsonUnmarshaller[*ChangeOwnerAddressParams]) @@ -37,7 +37,7 @@ func ChangeOwnerAddressValue(network string, height int64, txMetadata string) (i return nil, nil } -func ParseWithdrawBalanceValue(network string, height int64, txMetadata string) (interface{}, error) { +func (*Msig) ParseWithdrawBalanceValue(network string, height int64, txMetadata string) (interface{}, error) { switch { case tools.V16.IsSupported(network, height): return parse[*miner11.WithdrawBalanceParams, string](txMetadata, jsonUnmarshaller[*miner11.WithdrawBalanceParams]) @@ -59,7 +59,7 @@ func ParseWithdrawBalanceValue(network string, height int64, txMetadata string) return nil, nil } -func ParseInvokeContractValue(network string, height int64, txMetadata string) (interface{}, error) { +func (*Msig) ParseInvokeContractValue(network string, height int64, txMetadata string) (interface{}, error) { switch { case tools.V16.IsSupported(network, height): return parse[*InvokeContractParams, string](txMetadata, jsonUnmarshaller[*InvokeContractParams]) @@ -81,7 +81,7 @@ func ParseInvokeContractValue(network string, height int64, txMetadata string) ( return nil, nil } -func ParseAddSignerValue(network string, height int64, txMetadata string) (interface{}, error) { +func (*Msig) ParseAddSignerValue(network string, height int64, txMetadata string) (interface{}, error) { switch { case tools.V16.IsSupported(network, height): return parse[*multisig11.AddSignerParams, string](txMetadata, jsonUnmarshaller[*multisig11.AddSignerParams]) @@ -103,7 +103,7 @@ func ParseAddSignerValue(network string, height int64, txMetadata string) (inter return nil, nil } -func ParseApproveValue(network string, height int64, txMetadata string) (interface{}, error) { +func (*Msig) ParseApproveValue(network string, height int64, txMetadata string) (interface{}, error) { switch { case tools.V16.IsSupported(network, height): if data, err := parse[metadataWithCbor, string](txMetadata, jsonUnmarshaller[metadataWithCbor]); err != nil { @@ -157,7 +157,7 @@ func ParseApproveValue(network string, height int64, txMetadata string) (interfa return nil, nil } -func ParseCancelValue(network string, height int64, txMetadata string) (interface{}, error) { +func (*Msig) ParseCancelValue(network string, height int64, txMetadata string) (interface{}, error) { switch { case tools.V16.IsSupported(network, height): if data, err := parse[metadataWithCbor, string](txMetadata, jsonUnmarshaller[metadataWithCbor]); err != nil { @@ -211,7 +211,7 @@ func ParseCancelValue(network string, height int64, txMetadata string) (interfac return nil, nil } -func ChangeNumApprovalsThresholdValue(network string, height int64, txMetadata string) (interface{}, error) { +func (*Msig) ChangeNumApprovalsThresholdValue(network string, height int64, txMetadata string) (interface{}, error) { switch { case tools.V16.IsSupported(network, height): return parse[*multisig8.ChangeNumApprovalsThresholdParams, string](txMetadata, jsonUnmarshaller[*multisig8.ChangeNumApprovalsThresholdParams]) @@ -233,7 +233,7 @@ func ChangeNumApprovalsThresholdValue(network string, height int64, txMetadata s return nil, nil } -func ParseConstructorValue(network string, height int64, txMetadata string) (interface{}, error) { +func (*Msig) ParseConstructorValue(network string, height int64, txMetadata string) (interface{}, error) { switch { case tools.V16.IsSupported(network, height): if data, err := parse[*multisig8.ConstructorParams, string](txMetadata, jsonUnmarshaller[*multisig8.ConstructorParams]); err != nil { @@ -287,7 +287,7 @@ func ParseConstructorValue(network string, height int64, txMetadata string) (int return nil, nil } -func ParseLockBalanceValue(network string, height int64, txMetadata string) (interface{}, error) { +func (*Msig) ParseLockBalanceValue(network string, height int64, txMetadata string) (interface{}, error) { switch { case tools.V16.IsSupported(network, height): if data, err := parse[*multisig8.LockBalanceParams, string](txMetadata, jsonUnmarshaller[*multisig8.LockBalanceParams]); err != nil { @@ -341,7 +341,7 @@ func ParseLockBalanceValue(network string, height int64, txMetadata string) (int return nil, nil } -func ParseRemoveSignerValue(network string, height int64, txMetadata string) (interface{}, error) { +func (*Msig) ParseRemoveSignerValue(network string, height int64, txMetadata string) (interface{}, error) { switch { case tools.V16.IsSupported(network, height): if data, err := parse[*multisig8.RemoveSignerParams, string](txMetadata, jsonUnmarshaller[*multisig8.RemoveSignerParams]); err != nil { @@ -395,7 +395,7 @@ func ParseRemoveSignerValue(network string, height int64, txMetadata string) (in return nil, nil } -func ParseSendValue(network string, height int64, txMetadata string) (interface{}, error) { +func (*Msig) ParseSendValue(network string, height int64, txMetadata string) (interface{}, error) { switch { case tools.V16.IsSupported(network, height): return parse[*SendValue, string](txMetadata, jsonUnmarshaller[*SendValue]) @@ -417,7 +417,7 @@ func ParseSendValue(network string, height int64, txMetadata string) (interface{ return nil, nil } -func ParseSwapSignerValue(network string, height int64, txMetadata string) (interface{}, error) { +func (*Msig) ParseSwapSignerValue(network string, height int64, txMetadata string) (interface{}, error) { switch { case tools.V16.IsSupported(network, height): return parse[*multisig8.SwapSignerParams, string](txMetadata, jsonUnmarshaller[*multisig8.SwapSignerParams]) @@ -439,7 +439,7 @@ func ParseSwapSignerValue(network string, height int64, txMetadata string) (inte return nil, nil } -func ParseUniversalReceiverHookValue(network string, height int64, txMetadata string) (interface{}, error) { +func (*Msig) ParseUniversalReceiverHookValue(network string, height int64, txMetadata string) (interface{}, error) { var tx TransactionUniversalReceiverHookMetadata err := json.Unmarshal([]byte(txMetadata), &tx) if err != nil { diff --git a/actors/multisig/values_test.go b/actors/multisig/values_test.go deleted file mode 100644 index 7d5a4a4d..00000000 --- a/actors/multisig/values_test.go +++ /dev/null @@ -1,110 +0,0 @@ -package multisig_test - -import ( - "reflect" - "testing" - - "github.com/stretchr/testify/require" - "github.com/zondax/fil-parser/actors/multisig" - typesV2 "github.com/zondax/fil-parser/parser/v2/types" - "github.com/zondax/fil-parser/tools" -) - -type valueTestFn func(network string, height int64, txMetadata string) (interface{}, error) - -func TestChangeOwnerAddressValue(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "ChangeOwnerAddressValue", expected) - require.NoError(t, err) - runValueTest(t, multisig.ChangeOwnerAddressValue, tests) -} - -func TestParseWithdrawBalanceValue(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "ParseWithdrawBalanceValue", expected) - require.NoError(t, err) - runValueTest(t, multisig.ParseWithdrawBalanceValue, tests) -} - -func TestParseInvokeContractValue(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "ParseInvokeContractValue", expected) - require.NoError(t, err) - runValueTest(t, multisig.ParseInvokeContractValue, tests) -} - -func TestParseAddSignerValue(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "ParseAddSignerValue", expected) - require.NoError(t, err) - runValueTest(t, multisig.ParseAddSignerValue, tests) -} - -func TestParseApproveValue(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "ParseApproveValue", expected) - require.NoError(t, err) - runValueTest(t, multisig.ParseApproveValue, tests) -} - -func TestParseCancelValue(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "ParseCancelValue", expected) - require.NoError(t, err) - runValueTest(t, multisig.ParseCancelValue, tests) -} -func TestChangeNumApprovalsThresholdValue(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "ChangeNumApprovalsThresholdValue", expected) - require.NoError(t, err) - runValueTest(t, multisig.ChangeNumApprovalsThresholdValue, tests) -} - -func TestParseConstructorValue(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "ParseConstructorValue", expected) - require.NoError(t, err) - runValueTest(t, multisig.ParseConstructorValue, tests) -} - -func TestParseLockBalanceValue(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "ParseLockBalanceValue", expected) - require.NoError(t, err) - runValueTest(t, multisig.ParseLockBalanceValue, tests) -} - -func TestParseRemoveSignerValue(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "ParseRemoveSignerValue", expected) - require.NoError(t, err) - runValueTest(t, multisig.ParseRemoveSignerValue, tests) -} - -func TestParseSendValue(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "ParseSendValue", expected) - require.NoError(t, err) - runValueTest(t, multisig.ParseSendValue, tests) -} - -func TestParseSwapSignerValue(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "ParseSwapSignerValue", expected) - require.NoError(t, err) - runValueTest(t, multisig.ParseSwapSignerValue, tests) -} - -func TestParseUniversalReceiverHookValue(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "ParseUniversalReceiverHookValue", expected) - require.NoError(t, err) - runValueTest(t, multisig.ParseUniversalReceiverHookValue, tests) -} - -func runValueTest(t *testing.T, fn valueTestFn, tests []tools.TestCase[map[string]any]) { - for _, tt := range tests { - t.Run(tt.Name, func(t *testing.T) { - computeState, err := tools.ComputeState[typesV2.ComputeStateOutputV2](tt.Height, tt.Version) - require.NoError(t, err) - - for _, trace := range computeState.Trace { - if trace.Msg == nil { - continue - } - // TODO: parse whole multisig tx first before calling this function - - result, err := fn(tt.Network, tt.Height, string(trace.Msg.Params)) - require.NoError(t, err) - require.True(t, reflect.DeepEqual(result, tt.Expected)) - } - }) - } -} diff --git a/actors/multisig/verifier.go b/actors/multisig/verifier.go index 4bb7d67d..f5db9117 100644 --- a/actors/multisig/verifier.go +++ b/actors/multisig/verifier.go @@ -12,7 +12,7 @@ import ( "github.com/zondax/fil-parser/tools" ) -func AddVerifierValue(network string, height int64, txMetadata string) (interface{}, error) { +func (*Msig) AddVerifierValue(network string, height int64, txMetadata string) (interface{}, error) { switch { case tools.V16.IsSupported(network, height): return parse[*verifreg8.AddVerifierParams, string](txMetadata, jsonUnmarshaller[*verifreg8.AddVerifierParams]) diff --git a/actors/multisig/verifier_test.go b/actors/multisig/verifier_test.go deleted file mode 100644 index d9518518..00000000 --- a/actors/multisig/verifier_test.go +++ /dev/null @@ -1,15 +0,0 @@ -package multisig_test - -import ( - "testing" - - "github.com/stretchr/testify/require" - "github.com/zondax/fil-parser/actors/multisig" - "github.com/zondax/fil-parser/tools" -) - -func TestAddVerifierValue(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "AddVerifierValue", expected) - require.NoError(t, err) - runValueTest(t, multisig.AddVerifierValue, tests) -} diff --git a/actors/paymentChannel/paymentChannel.go b/actors/paymentChannel/paymentChannel.go index f1b921e4..aaec79e6 100644 --- a/actors/paymentChannel/paymentChannel.go +++ b/actors/paymentChannel/paymentChannel.go @@ -14,11 +14,12 @@ import ( "github.com/zondax/fil-parser/tools" ) +type PaymentChannel struct{} type paymentChannelParams interface { UnmarshalCBOR(io.Reader) error } -func PaymentChannelConstructor(network string, height int64, raw []byte) (map[string]interface{}, error) { +func (*PaymentChannel) PaymentChannelConstructor(network string, height int64, raw []byte) (map[string]interface{}, error) { switch { case tools.V16.IsSupported(network, height): return parse[*paychv8.ConstructorParams](raw) @@ -40,7 +41,7 @@ func PaymentChannelConstructor(network string, height int64, raw []byte) (map[st return nil, nil } -func UpdateChannelState(network string, height int64, raw []byte) (map[string]interface{}, error) { +func (*PaymentChannel) UpdateChannelState(network string, height int64, raw []byte) (map[string]interface{}, error) { switch { case tools.V16.IsSupported(network, height): return parse[*paychv8.UpdateChannelStateParams](raw) diff --git a/actors/paymentChannel/paymentChannel_test.go b/actors/paymentChannel/paymentChannel_test.go index fffcd0dc..2ed2d9c6 100644 --- a/actors/paymentChannel/paymentChannel_test.go +++ b/actors/paymentChannel/paymentChannel_test.go @@ -33,16 +33,19 @@ type test struct { expected map[string]interface{} } -func TestPaymentChannelConstructor(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "PaymentChannelConstructor", expected) - require.NoError(t, err) - runTest(t, paymentchannel.PaymentChannelConstructor, tests) -} - -func TestUpdateChannelState(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "UpdateChannelState", expected) - require.NoError(t, err) - runTest(t, paymentchannel.UpdateChannelState, tests) +func TestPaymentChannel(t *testing.T) { + paymentchannel := &paymentchannel.PaymentChannel{} + testFns := map[string]testFn{ + "PaymentChannelConstructor": paymentchannel.PaymentChannelConstructor, + "UpdateChannelState": paymentchannel.UpdateChannelState, + } + for name, fn := range testFns { + t.Run(name, func(t *testing.T) { + tests, err := tools.LoadTestData[map[string]any](network, name, expected) + require.NoError(t, err) + runTest(t, fn, tests) + }) + } } func runTest(t *testing.T, fn testFn, tests []tools.TestCase[map[string]any]) { diff --git a/actors/power/power.go b/actors/power/power.go index bf40acd1..e70d5ac8 100644 --- a/actors/power/power.go +++ b/actors/power/power.go @@ -17,7 +17,9 @@ import ( "github.com/zondax/fil-parser/tools" ) -func CurrentTotalPower(network string, msg *parser.LotusMessage, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { +type Power struct{} + +func (*Power) CurrentTotalPower(network string, msg *parser.LotusMessage, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch { case tools.V16.IsSupported(network, height): data, _, err := parse[*powerv8.CurrentTotalPowerReturn, *powerv8.CurrentTotalPowerReturn](msg, raw, rawReturn, false) @@ -47,12 +49,12 @@ func CurrentTotalPower(network string, msg *parser.LotusMessage, height int64, r return nil, nil } -func SubmitPoRepForBulkVerify(network string, msg *parser.LotusMessage, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { +func (*Power) SubmitPoRepForBulkVerify(network string, msg *parser.LotusMessage, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { data, _, err := parse[*proof.SealVerifyInfo, *proof.SealVerifyInfo](msg, raw, rawReturn, false) return data, err } -func PowerConstructor(network string, height int64, msg *parser.LotusMessage, raw []byte) (map[string]interface{}, error) { +func (*Power) PowerConstructor(network string, height int64, msg *parser.LotusMessage, raw []byte) (map[string]interface{}, error) { switch { case tools.V16.IsSupported(network, height): data, _, err := parse[*powerv8.MinerConstructorParams, *powerv8.MinerConstructorParams](msg, raw, nil, false) @@ -82,7 +84,7 @@ func PowerConstructor(network string, height int64, msg *parser.LotusMessage, ra return nil, nil } -func CreateMiner(network string, msg *parser.LotusMessage, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { +func (*Power) CreateMiner(network string, msg *parser.LotusMessage, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch { case tools.V16.IsSupported(network, height): data, _, err := parse[*powerv8.CreateMinerParams, *powerv8.CreateMinerReturn](msg, raw, rawReturn, true) @@ -112,7 +114,7 @@ func CreateMiner(network string, msg *parser.LotusMessage, height int64, raw, ra return nil, nil } -func EnrollCronEvent(network string, msg *parser.LotusMessage, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { +func (*Power) EnrollCronEvent(network string, msg *parser.LotusMessage, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch { case tools.V16.IsSupported(network, height): data, _, err := parse[*powerv8.EnrollCronEventParams, *powerv8.EnrollCronEventParams](msg, raw, rawReturn, true) @@ -142,7 +144,7 @@ func EnrollCronEvent(network string, msg *parser.LotusMessage, height int64, raw return nil, nil } -func UpdateClaimedPower(network string, msg *parser.LotusMessage, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { +func (*Power) UpdateClaimedPower(network string, msg *parser.LotusMessage, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch { case tools.V16.IsSupported(network, height): data, _, err := parse[*powerv8.UpdateClaimedPowerParams, *powerv8.UpdateClaimedPowerParams](msg, raw, rawReturn, true) @@ -172,7 +174,7 @@ func UpdateClaimedPower(network string, msg *parser.LotusMessage, height int64, return nil, nil } -func UpdatePledgeTotal(network string, msg *parser.LotusMessage, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { +func (*Power) UpdatePledgeTotal(network string, msg *parser.LotusMessage, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch { case tools.V16.IsSupported(network, height): data, _, err := parse[*abi.TokenAmount, *abi.TokenAmount](msg, raw, rawReturn, false) @@ -202,7 +204,7 @@ func UpdatePledgeTotal(network string, msg *parser.LotusMessage, height int64, r return nil, nil } -func NetworkRawPower(network string, msg *parser.LotusMessage, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { +func (*Power) NetworkRawPower(network string, msg *parser.LotusMessage, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch { case tools.V16.IsSupported(network, height): return nil, fmt.Errorf("not supported") @@ -230,7 +232,7 @@ func NetworkRawPower(network string, msg *parser.LotusMessage, height int64, raw return nil, nil } -func MinerRawPower(network string, msg *parser.LotusMessage, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { +func (*Power) MinerRawPower(network string, msg *parser.LotusMessage, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch { case tools.V16.IsSupported(network, height): return nil, fmt.Errorf("not supported") @@ -258,7 +260,7 @@ func MinerRawPower(network string, msg *parser.LotusMessage, height int64, raw, return nil, nil } -func MinerCount(network string, msg *parser.LotusMessage, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { +func (*Power) MinerCount(network string, msg *parser.LotusMessage, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch { case tools.V16.IsSupported(network, height): return nil, fmt.Errorf("not supported") @@ -286,7 +288,7 @@ func MinerCount(network string, msg *parser.LotusMessage, height int64, raw, raw return nil, nil } -func MinerConsensusCount(network string, msg *parser.LotusMessage, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { +func (*Power) MinerConsensusCount(network string, msg *parser.LotusMessage, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch { case tools.V16.IsSupported(network, height): return nil, fmt.Errorf("not supported") diff --git a/actors/power/power_test.go b/actors/power/power_test.go index 1247e652..007b3114 100644 --- a/actors/power/power_test.go +++ b/actors/power/power_test.go @@ -28,64 +28,27 @@ func TestMain(m *testing.M) { type testFn func(network string, msg *parser.LotusMessage, height int64, raw, rawReturn []byte) (map[string]interface{}, error) -func TestCurrentTotalPower(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "CurrentTotalPower", expected) - require.NoError(t, err) - runTest(t, power.CurrentTotalPower, tests) -} - -func TestSubmitPoRepForBulkVerify(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "SubmitPoRepForBulkVerify", expected) - require.NoError(t, err) - runTest(t, power.SubmitPoRepForBulkVerify, tests) -} - -func TestCreateMiner(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "CreateMiner", expected) - require.NoError(t, err) - runTest(t, power.CreateMiner, tests) -} - -func TestEnrollCronEvent(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "EnrollCronEvent", expected) - require.NoError(t, err) - runTest(t, power.EnrollCronEvent, tests) -} - -func TestUpdateClaimedPower(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "UpdateClaimedPower", expected) - require.NoError(t, err) - runTest(t, power.UpdateClaimedPower, tests) -} - -func TestUpdatePledgeTotal(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "UpdatePledgeTotal", expected) - require.NoError(t, err) - runTest(t, power.UpdatePledgeTotal, tests) -} - -func TestNetworkRawPower(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "NetworkRawPower", expected) - require.NoError(t, err) - runTest(t, power.NetworkRawPower, tests) -} - -func TestMinerRawPower(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "MinerRawPower", expected) - require.NoError(t, err) - runTest(t, power.MinerRawPower, tests) -} - -func TestMinerCount(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "MinerCount", expected) - require.NoError(t, err) - runTest(t, power.MinerCount, tests) -} - -func TestMinerConsensusCount(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "MinerConsensusCount", expected) - require.NoError(t, err) - runTest(t, power.MinerConsensusCount, tests) +func TestPower(t *testing.T) { + power := &power.Power{} + testFns := map[string]testFn{ + "CurrentTotalPower": power.CurrentTotalPower, + "SubmitPoRepForBulkVerify": power.SubmitPoRepForBulkVerify, + "CreateMiner": power.CreateMiner, + "EnrollCronEvent": power.EnrollCronEvent, + "UpdateClaimedPower": power.UpdateClaimedPower, + "UpdatePledgeTotal": power.UpdatePledgeTotal, + "NetworkRawPower": power.NetworkRawPower, + "MinerRawPower": power.MinerRawPower, + "MinerCount": power.MinerCount, + "MinerConsensusCount": power.MinerConsensusCount, + } + for name, fn := range testFns { + t.Run(name, func(t *testing.T) { + tests, err := tools.LoadTestData[map[string]any](network, name, expected) + require.NoError(t, err) + runTest(t, fn, tests) + }) + } } func TestPowerConstructor(t *testing.T) { @@ -106,6 +69,7 @@ func TestPowerConstructor(t *testing.T) { From: trace.Msg.From, Method: trace.Msg.Method, } + power := &power.Power{} result, err := power.PowerConstructor(tt.Network, tt.Height, lotusMsg, trace.Msg.Params) require.NoError(t, err) require.True(t, tools.CompareResult(result, tt.Expected)) diff --git a/actors/reward/reward.go b/actors/reward/reward.go index 6cef55da..f6c52f44 100644 --- a/actors/reward/reward.go +++ b/actors/reward/reward.go @@ -13,11 +13,13 @@ import ( "github.com/zondax/fil-parser/tools" ) -func RewardConstructor(network string, height int64, raw []byte) (map[string]interface{}, error) { +type Reward struct{} + +func (*Reward) RewardConstructor(network string, height int64, raw []byte) (map[string]interface{}, error) { return parse[*abi.StoragePower](raw) } -func AwardBlockReward(network string, height int64, raw []byte) (map[string]interface{}, error) { +func (*Reward) AwardBlockReward(network string, height int64, raw []byte) (map[string]interface{}, error) { switch { case tools.V16.IsSupported(network, height): return parse[*rewardv8.AwardBlockRewardParams](raw) @@ -39,11 +41,11 @@ func AwardBlockReward(network string, height int64, raw []byte) (map[string]inte return nil, nil } -func UpdateNetworkKPI(network string, height int64, raw []byte) (map[string]interface{}, error) { +func (*Reward) UpdateNetworkKPI(network string, height int64, raw []byte) (map[string]interface{}, error) { return parse[*abi.StoragePower](raw) } -func ThisEpochReward(network string, height int64, raw []byte) (map[string]interface{}, error) { +func (*Reward) ThisEpochReward(network string, height int64, raw []byte) (map[string]interface{}, error) { switch { case tools.V16.IsSupported(network, height): return parse[*rewardv8.ThisEpochRewardReturn](raw) diff --git a/actors/reward/reward_test.go b/actors/reward/reward_test.go index 97b8a54d..956586c4 100644 --- a/actors/reward/reward_test.go +++ b/actors/reward/reward_test.go @@ -27,28 +27,21 @@ func TestMain(m *testing.M) { type testFn func(network string, height int64, raw []byte) (map[string]interface{}, error) -func TestRewardConstructor(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "RewardConstructor", expected) - require.NoError(t, err) - runTest(t, reward.RewardConstructor, tests) -} - -func TestAwardBlockReward(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "AwardBlockReward", expected) - require.NoError(t, err) - runTest(t, reward.AwardBlockReward, tests) -} - -func TestUpdateNetworkKPI(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "UpdateNetworkKPI", expected) - require.NoError(t, err) - runTest(t, reward.UpdateNetworkKPI, tests) -} - -func TestThisEpochReward(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "ThisEpochReward", expected) - require.NoError(t, err) - runTest(t, reward.ThisEpochReward, tests) +func TestReward(t *testing.T) { + reward := &reward.Reward{} + testFns := map[string]testFn{ + "RewardConstructor": reward.RewardConstructor, + "AwardBlockReward": reward.AwardBlockReward, + "UpdateNetworkKPI": reward.UpdateNetworkKPI, + "ThisEpochReward": reward.ThisEpochReward, + } + for name, fn := range testFns { + t.Run(name, func(t *testing.T) { + tests, err := tools.LoadTestData[map[string]any](network, name, expected) + require.NoError(t, err) + runTest(t, fn, tests) + }) + } } func runTest(t *testing.T, fn testFn, tests []tools.TestCase[map[string]any]) { diff --git a/actors/verifiedRegistry/verifiedRegistry.go b/actors/verifiedRegistry/verifiedRegistry.go index f04495e9..c7af9788 100644 --- a/actors/verifiedRegistry/verifiedRegistry.go +++ b/actors/verifiedRegistry/verifiedRegistry.go @@ -16,7 +16,9 @@ import ( "github.com/zondax/fil-parser/tools" ) -func AddVerifier(network string, height int64, raw []byte) (map[string]interface{}, error) { +type VerifiedRegistry struct{} + +func (*VerifiedRegistry) AddVerifier(network string, height int64, raw []byte) (map[string]interface{}, error) { switch { case tools.V16.IsSupported(network, height): return parse[*verifregv8.AddVerifierParams, *verifregv8.AddVerifierParams](raw, nil, false) @@ -38,11 +40,11 @@ func AddVerifier(network string, height int64, raw []byte) (map[string]interface return nil, nil } -func RemoveVerifier(network string, height int64, raw []byte) (map[string]interface{}, error) { +func (*VerifiedRegistry) RemoveVerifier(network string, height int64, raw []byte) (map[string]interface{}, error) { return parse[*address.Address, *address.Address](raw, nil, false) } -func AddVerifiedClient(network string, height int64, raw []byte) (map[string]interface{}, error) { +func (*VerifiedRegistry) AddVerifiedClient(network string, height int64, raw []byte) (map[string]interface{}, error) { switch { case tools.V16.IsSupported(network, height): return parse[*verifregv8.AddVerifiedClientParams, *verifregv8.AddVerifiedClientParams](raw, nil, false) @@ -64,7 +66,7 @@ func AddVerifiedClient(network string, height int64, raw []byte) (map[string]int return nil, nil } -func UseBytes(network string, height int64, raw []byte) (map[string]interface{}, error) { +func (*VerifiedRegistry) UseBytes(network string, height int64, raw []byte) (map[string]interface{}, error) { switch { case tools.V16.IsSupported(network, height): return parse[*verifregv8.UseBytesParams, *verifregv8.UseBytesParams](raw, nil, false) @@ -86,7 +88,7 @@ func UseBytes(network string, height int64, raw []byte) (map[string]interface{}, return nil, nil } -func RestoreBytes(network string, height int64, raw []byte) (map[string]interface{}, error) { +func (*VerifiedRegistry) RestoreBytes(network string, height int64, raw []byte) (map[string]interface{}, error) { switch { case tools.V16.IsSupported(network, height): return parse[*verifregv8.RestoreBytesParams, *verifregv8.RestoreBytesParams](raw, nil, false) @@ -108,7 +110,7 @@ func RestoreBytes(network string, height int64, raw []byte) (map[string]interfac return nil, nil } -func RemoveVerifiedClientDataCap(network string, height int64, raw []byte) (map[string]interface{}, error) { +func (*VerifiedRegistry) RemoveVerifiedClientDataCap(network string, height int64, raw []byte) (map[string]interface{}, error) { switch { case tools.V16.IsSupported(network, height): return parse[*verifregv8.DataCap, *verifregv8.DataCap](raw, nil, false) @@ -130,7 +132,7 @@ func RemoveVerifiedClientDataCap(network string, height int64, raw []byte) (map[ return nil, nil } -func RemoveExpiredAllocations(network string, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { +func (*VerifiedRegistry) RemoveExpiredAllocations(network string, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch { case tools.V16.IsSupported(network, height): return nil, fmt.Errorf("not supported") @@ -152,7 +154,7 @@ func RemoveExpiredAllocations(network string, height int64, raw, rawReturn []byt return nil, nil } -func Deprecated1(network string, height int64, raw []byte) (map[string]interface{}, error) { +func (*VerifiedRegistry) Deprecated1(network string, height int64, raw []byte) (map[string]interface{}, error) { switch { case tools.V16.IsSupported(network, height): return parse[*verifregv8.RestoreBytesParams, *verifregv8.RestoreBytesParams](raw, nil, false) @@ -174,7 +176,7 @@ func Deprecated1(network string, height int64, raw []byte) (map[string]interface return nil, nil } -func Deprecated2(network string, height int64, raw []byte) (map[string]interface{}, error) { +func (*VerifiedRegistry) Deprecated2(network string, height int64, raw []byte) (map[string]interface{}, error) { switch { case tools.V16.IsSupported(network, height): return parse[*verifregv8.UseBytesParams, *verifregv8.UseBytesParams](raw, nil, false) @@ -196,7 +198,7 @@ func Deprecated2(network string, height int64, raw []byte) (map[string]interface return nil, nil } -func ClaimAllocations(network string, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { +func (*VerifiedRegistry) ClaimAllocations(network string, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch { case tools.V16.IsSupported(network, height): return nil, fmt.Errorf("not supported") @@ -218,7 +220,7 @@ func ClaimAllocations(network string, height int64, raw, rawReturn []byte) (map[ return nil, nil } -func GetClaims(network string, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { +func (*VerifiedRegistry) GetClaims(network string, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch { case tools.V16.IsSupported(network, height): return nil, fmt.Errorf("not supported") @@ -240,7 +242,7 @@ func GetClaims(network string, height int64, raw, rawReturn []byte) (map[string] return nil, nil } -func ExtendClaimTerms(network string, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { +func (*VerifiedRegistry) ExtendClaimTerms(network string, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch { case tools.V16.IsSupported(network, height): return nil, fmt.Errorf("not supported") @@ -262,7 +264,7 @@ func ExtendClaimTerms(network string, height int64, raw, rawReturn []byte) (map[ return nil, nil } -func RemoveExpiredClaims(network string, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { +func (*VerifiedRegistry) RemoveExpiredClaims(network string, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch { case tools.V16.IsSupported(network, height): return nil, fmt.Errorf("not supported") @@ -284,7 +286,7 @@ func RemoveExpiredClaims(network string, height int64, raw, rawReturn []byte) (m return nil, nil } -func VerifregUniversalReceiverHook(network string, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { +func (*VerifiedRegistry) VerifregUniversalReceiverHook(network string, height int64, raw, rawReturn []byte) (map[string]interface{}, error) { switch { case tools.V16.IsSupported(network, height): return nil, fmt.Errorf("not supported") diff --git a/actors/verifiedRegistry/verifiedRegistry_test.go b/actors/verifiedRegistry/verifiedRegistry_test.go index 955f828f..de00fddf 100644 --- a/actors/verifiedRegistry/verifiedRegistry_test.go +++ b/actors/verifiedRegistry/verifiedRegistry_test.go @@ -28,87 +28,44 @@ func TestMain(m *testing.M) { type testFn func(network string, height int64, raw []byte) (map[string]interface{}, error) type testFn2 func(network string, height int64, raw, rawReturn []byte) (map[string]interface{}, error) -func TestAddVerifier(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "AddVerifier", expected) - require.NoError(t, err) - runTest(t, verifiedregistry.AddVerifier, tests) -} - -func TestRemoveVerifier(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "RemoveVerifier", expected) - require.NoError(t, err) - runTest(t, verifiedregistry.RemoveVerifier, tests) -} - -func TestAddVerifiedClient(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "AddVerifiedClient", expected) - require.NoError(t, err) - runTest(t, verifiedregistry.AddVerifiedClient, tests) -} - -func TestUseBytes(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "UseBytes", expected) - require.NoError(t, err) - runTest(t, verifiedregistry.UseBytes, tests) -} - -func TestRestoreBytes(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "RestoreBytes", expected) - require.NoError(t, err) - runTest(t, verifiedregistry.RestoreBytes, tests) -} - -func TestRemoveVerifiedClientDataCap(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "RemoveVerifiedClientDataCap", expected) - require.NoError(t, err) - runTest(t, verifiedregistry.RemoveVerifiedClientDataCap, tests) -} - -func TestDeprecated1(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "Deprecated1", expected) - require.NoError(t, err) - runTest(t, verifiedregistry.Deprecated1, tests) -} - -func TestDeprecated2(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "Deprecated2", expected) - require.NoError(t, err) - runTest(t, verifiedregistry.Deprecated2, tests) -} - -func TestClaimAllocations(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "ClaimAllocations", expected) - require.NoError(t, err) - runTest2(t, verifiedregistry.ClaimAllocations, tests) -} - -func TestGetClaims(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "GetClaims", expected) - require.NoError(t, err) - runTest2(t, verifiedregistry.GetClaims, tests) -} - -func TestExtendClaimTerms(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "ExtendClaimTerms", expected) - require.NoError(t, err) - runTest2(t, verifiedregistry.ExtendClaimTerms, tests) -} - -func TestRemoveExpiredClaims(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "RemoveExpiredClaims", expected) - require.NoError(t, err) - runTest2(t, verifiedregistry.RemoveExpiredClaims, tests) +func TestVerifiedRegistry(t *testing.T) { + verifiedregistry := &verifiedregistry.VerifiedRegistry{} + testFns := map[string]testFn{ + "AddVerifier": verifiedregistry.AddVerifier, + "RemoveVerifier": verifiedregistry.RemoveVerifier, + "AddVerifiedClient": verifiedregistry.AddVerifiedClient, + "UseBytes": verifiedregistry.UseBytes, + "RestoreBytes": verifiedregistry.RestoreBytes, + "RemoveVerifiedClientDataCap": verifiedregistry.RemoveVerifiedClientDataCap, + "Deprecated1": verifiedregistry.Deprecated1, + "Deprecated2": verifiedregistry.Deprecated2, + } + for name, fn := range testFns { + t.Run(name, func(t *testing.T) { + tests, err := tools.LoadTestData[map[string]any](network, name, expected) + require.NoError(t, err) + runTest(t, fn, tests) + }) + } } -func TestVerifregUniversalReceiverHook(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "VerifregUniversalReceiverHook", expected) - require.NoError(t, err) - runTest2(t, verifiedregistry.VerifregUniversalReceiverHook, tests) -} -func TestRemoveExpiredAllocations(t *testing.T) { - tests, err := tools.LoadTestData[map[string]any](network, "RemoveExpiredAllocations", expected) - require.NoError(t, err) - runTest2(t, verifiedregistry.RemoveExpiredAllocations, tests) +func TestVerifiedRegistry2(t *testing.T) { + verifiedregistry := &verifiedregistry.VerifiedRegistry{} + testFns := map[string]testFn2{ + "ClaimAllocations": verifiedregistry.ClaimAllocations, + "GetClaims": verifiedregistry.GetClaims, + "ExtendClaimTerms": verifiedregistry.ExtendClaimTerms, + "RemoveExpiredClaims": verifiedregistry.RemoveExpiredClaims, + "VerifregUniversalReceiverHook": verifiedregistry.VerifregUniversalReceiverHook, + "RemoveExpiredAllocations": verifiedregistry.RemoveExpiredAllocations, + } + for name, fn := range testFns { + t.Run(name, func(t *testing.T) { + tests, err := tools.LoadTestData[map[string]any](network, name, expected) + require.NoError(t, err) + runTest2(t, fn, tests) + }) + } } func runTest(t *testing.T, fn testFn, tests []tools.TestCase[map[string]any]) { diff --git a/cmd/tracedl/cli.go b/cmd/tracedl/cli.go index ee16a216..c1b361a0 100644 --- a/cmd/tracedl/cli.go +++ b/cmd/tracedl/cli.go @@ -3,6 +3,7 @@ package main import ( "bytes" "compress/gzip" + "encoding/json" "fmt" "io" "io/fs" @@ -13,6 +14,8 @@ import ( lotusChainTypes "github.com/filecoin-project/lotus/chain/types" "github.com/klauspost/compress/s2" "github.com/spf13/cobra" + "github.com/zondax/fil-parser/actors/account" + typesV2 "github.com/zondax/fil-parser/parser/v2/types" "github.com/zondax/golem/pkg/cli" "go.uber.org/zap" ) @@ -33,6 +36,33 @@ func GetStartCommand(c *cli.CLI) *cobra.Command { return cmd } +func getTrace(height uint64, logType string, rpcClient *RPCClient) ([]byte, error) { + var data any + var err error + switch logType { + case "traces": + data, err = getTraceFileByHeight(height, rpcClient.client) + case "tipset": + data, err = getTipsetFileByHeight(height, lotusChainTypes.EmptyTSK, rpcClient.client) + case "ethlog": + data, err = getEthLogsByHeight(height, rpcClient.client) + case "nativelog": + data, err = getNativeLogsByHeight(height, rpcClient.client) + case "metadata": + data, err = getMetadata(rpcClient) + } + + if err != nil { + return nil, err + } + + dataJson, err := sonic.Marshal(data) + if err != nil { + return nil, err + } + return dataJson, nil +} + func get(c *cli.CLI, cmd *cobra.Command, _ []string) { zap.S().Infof(c.GetVersionString()) @@ -71,30 +101,18 @@ func get(c *cli.CLI, cmd *cobra.Command, _ []string) { if len(heights) > 0 { for _, tmp := range heights { height := uint64(tmp) - var data any - switch logType { - case "traces": - data, err = getTraceFileByHeight(height, rpcClient.client) - case "tipset": - data, err = getTipsetFileByHeight(height, lotusChainTypes.EmptyTSK, rpcClient.client) - case "ethlog": - data, err = getEthLogsByHeight(height, rpcClient.client) - case "nativelog": - data, err = getNativeLogsByHeight(height, rpcClient.client) - case "metadata": - data, err = getMetadata(rpcClient) - } - + dataJson, err := getTrace(height, logType, rpcClient) if err != nil { zap.S().Error(err) return } - - dataJson, err := sonic.Marshal(data) + actorJson, err := DownloadActorJSON(height, dataJson) if err != nil { zap.S().Error(err) - return + continue } + fmt.Println(string(actorJson)) + out := dataJson fname := fmt.Sprintf("%s_%d.json", logType, height) if format != "" { @@ -150,3 +168,26 @@ func compress(format string, data []byte) ([]byte, error) { return b.Bytes(), nil } + +func DownloadActorJSON(height uint64, traces []byte) ([]byte, error) { + var computeState *typesV2.ComputeStateOutputV2 + err := sonic.Unmarshal(traces, &computeState) + if err != nil { + return nil, err + } + if len(computeState.Trace) == 0 { + return nil, fmt.Errorf("no traces found") + } + resp, err := account.AuthenticateMessage("mainnet", 10000, computeState.Trace[0].Msg.Params, computeState.Trace[0].MsgRct.Return) + if err != nil { + return nil, err + } + data, err := json.Marshal(resp) + if err != nil { + return nil, err + } + if string(data) == "{}" { + return nil, fmt.Errorf("no data found") + } + return data, nil +} diff --git a/cmd/tracedl/pkg.go b/cmd/tracedl/pkg.go new file mode 100644 index 00000000..310bae84 --- /dev/null +++ b/cmd/tracedl/pkg.go @@ -0,0 +1,126 @@ +package main + +import ( + "fmt" + "reflect" +) + +// FunctionInfo holds information about an exported function +type FunctionInfo struct { + Name string + NumParams int + ParamTypes []reflect.Type + ReturnTypes []reflect.Type +} + +// PackageExporter handles discovery and execution of exported functions +type PackageExporter struct { + pkg interface{} + functionCache map[string]reflect.Value + functionInfo map[string]FunctionInfo +} + +// NewPackageExporter creates a new PackageExporter instance +func NewPackageExporter(pkg interface{}) *PackageExporter { + pe := &PackageExporter{ + pkg: pkg, + functionCache: make(map[string]reflect.Value), + functionInfo: make(map[string]FunctionInfo), + } + pe.discoverFunctions() + return pe +} + +// discoverFunctions finds all exported functions and caches their information +func (pe *PackageExporter) discoverFunctions() { + pkgType := reflect.TypeOf(pe.pkg) + pkgValue := reflect.ValueOf(pe.pkg) + + for i := 0; i < pkgType.NumMethod(); i++ { + method := pkgType.Method(i) + if !method.IsExported() { + continue + } + + methodType := method.Type + info := FunctionInfo{ + Name: method.Name, + NumParams: methodType.NumIn() - 1, // subtract 1 for receiver + ParamTypes: make([]reflect.Type, methodType.NumIn()-1), + ReturnTypes: make([]reflect.Type, methodType.NumOut()), + } + + // Get parameter types + for j := 1; j < methodType.NumIn(); j++ { // start from 1 to skip receiver + info.ParamTypes[j-1] = methodType.In(j) + } + + // Get return types + for j := 0; j < methodType.NumOut(); j++ { + info.ReturnTypes[j] = methodType.Out(j) + } + + pe.functionInfo[method.Name] = info + pe.functionCache[method.Name] = pkgValue.Method(i) + } +} + +// GetExportedFunctions returns information about all exported functions +func (pe *PackageExporter) GetExportedFunctions() []FunctionInfo { + functions := make([]FunctionInfo, 0, len(pe.functionInfo)) + for _, info := range pe.functionInfo { + functions = append(functions, info) + } + return functions +} + +// CallFunction calls an exported function by name with the provided arguments +func (pe *PackageExporter) CallFunction(functionName string, args ...interface{}) ([]interface{}, error) { + // Check if function exists + method, exists := pe.functionCache[functionName] + if !exists { + return nil, fmt.Errorf("function %s not found", functionName) + } + + info := pe.functionInfo[functionName] + + // Check number of arguments + if len(args) != info.NumParams { + return nil, fmt.Errorf("function %s expects %d arguments, got %d", + functionName, info.NumParams, len(args)) + } + + // Convert and type check arguments + reflectArgs := make([]reflect.Value, len(args)) + for i, arg := range args { + argValue := reflect.ValueOf(arg) + expectedType := info.ParamTypes[i] + + if !argValue.Type().AssignableTo(expectedType) { + return nil, fmt.Errorf("argument %d type mismatch: expected %v, got %v", + i, expectedType, argValue.Type()) + } + reflectArgs[i] = argValue + } + + // Call the function + results := method.Call(reflectArgs) + + // Convert results to interface slice + returnValues := make([]interface{}, len(results)) + for i, result := range results { + returnValues[i] = result.Interface() + } + + // Check if the last return value is an error + if len(results) > 0 { + lastResult := results[len(results)-1] + if lastResult.Type().Implements(reflect.TypeOf((*error)(nil)).Elem()) { + if !lastResult.IsNil() { + return returnValues[:len(returnValues)-1], lastResult.Interface().(error) + } + } + } + + return returnValues, nil +} diff --git a/tools/version_mapping.go b/tools/version_mapping.go index 882ff1f8..e3fcb61e 100644 --- a/tools/version_mapping.go +++ b/tools/version_mapping.go @@ -101,3 +101,21 @@ func GetSupportedVersions(network string) []version { } return result } + +func VersionsBefore(version version) []version { + for i, v := range supportedVersions { + if v.nodeVersion == version.nodeVersion { + return supportedVersions[:i+1] + } + } + return nil +} + +func VersionsAfter(version version) []version { + for i, v := range supportedVersions { + if v.nodeVersion == version.nodeVersion { + return supportedVersions[i:] + } + } + return nil +}