diff --git a/tools/miner/info.go b/tools/miner/info.go index 4f06f785..4513f044 100644 --- a/tools/miner/info.go +++ b/tools/miner/info.go @@ -4,8 +4,6 @@ import ( "encoding/json" "fmt" - "github.com/filecoin-project/go-address" - "github.com/zondax/fil-parser/actors" "github.com/zondax/fil-parser/parser" "github.com/zondax/fil-parser/tools" "github.com/zondax/fil-parser/types" @@ -64,19 +62,22 @@ func (eg *eventGenerator) parseAwardBlockReward(tx *types.Transaction, tipsetCid if err != nil { return nil, fmt.Errorf("error parsing params: %w", err) } + minerAddress, err := getItem[string](params, KeyMiner, false) if err != nil { return nil, fmt.Errorf("error parsing miner address: %w", err) } if eg.config.ConsolidateRobustAddress { - addr, err := address.NewFromString(minerAddress) - if err != nil { - return nil, fmt.Errorf("error parsing miner address: %w", err) - } - minerAddress, err = actors.ConsolidateToRobustAddress(addr, eg.helper, eg.logger, eg.config.RobustAddressBestEffort) - if err != nil { - return nil, fmt.Errorf("error consolidating miner address: %w", err) + if minerAddress != "" { + parsedMinerAddress, err := eg.consolidateAddress(minerAddress) + if err != nil { + eg.logger.Errorf("error consolidating miner address: %w", err) + } else { + minerAddress = parsedMinerAddress + params[KeyMiner] = minerAddress + } } + value[KeyParams] = params } return &types.MinerInfo{ ID: tools.BuildId(tipsetCid, tx.TxCid, tx.TxFrom, tx.TxTo, fmt.Sprint(tx.Height), tx.TxType), @@ -100,71 +101,14 @@ func (eg *eventGenerator) parseConstructor(tx *types.Transaction, tipsetCid, act if err != nil { return nil, fmt.Errorf("error parsing params: %w", err) } - ownerAddress, err := getItem[string](params, KeyOwnerAddr, false) - if err != nil { - return nil, fmt.Errorf("error parsing miner address: %w", err) - } - workerAddress, err := getItem[string](params, KeyWorkerAddr, false) - if err != nil { - return nil, fmt.Errorf("error parsing miner address: %w", err) - } - controlAddresses, err := getSlice[string](params, KeyControlAddrs, false) - if err != nil { - return nil, fmt.Errorf("error parsing miner address: %w", err) - } - multiaddrs, err := getSlice[string](params, KeyMultiaddrs, false) - if err != nil { - return nil, fmt.Errorf("error parsing miner address: %w", err) - } if eg.config.ConsolidateRobustAddress { - addr, err := address.NewFromString(ownerAddress) - if err != nil { - return nil, fmt.Errorf("error parsing miner address: %w", err) - } - ownerAddress, err = actors.ConsolidateToRobustAddress(addr, eg.helper, eg.logger, eg.config.RobustAddressBestEffort) - if err != nil { - return nil, fmt.Errorf("error consolidating miner address: %w", err) - } - addr, err = address.NewFromString(workerAddress) - if err != nil { - return nil, fmt.Errorf("error parsing miner address: %w", err) - } - workerAddress, err = actors.ConsolidateToRobustAddress(addr, eg.helper, eg.logger, eg.config.RobustAddressBestEffort) - if err != nil { - return nil, fmt.Errorf("error consolidating miner address: %w", err) - } - consolidatedControlAddrs := make([]string, 0, len(controlAddresses)) - consolidatedMultiAddrs := make([]string, 0, len(multiaddrs)) - for _, addrStr := range controlAddresses { - addr, err = address.NewFromString(addrStr) - if err != nil { - return nil, fmt.Errorf("error parsing miner address: %w", err) - } - controlAddress, err := actors.ConsolidateToRobustAddress(addr, eg.helper, eg.logger, eg.config.RobustAddressBestEffort) - if err != nil { - return nil, fmt.Errorf("error consolidating miner address: %w", err) - } - consolidatedControlAddrs = append(consolidatedControlAddrs, controlAddress) + if err := eg.consolidateConstructorAddresses(params); err != nil { + eg.logger.Errorf("error consolidating constructor addresses: %w", err) + } else { + value[KeyParams] = params } - for _, addrStr := range multiaddrs { - addr, err = address.NewFromString(addrStr) - if err != nil { - return nil, fmt.Errorf("error parsing miner address: %w", err) - } - multiAddr, err := actors.ConsolidateToRobustAddress(addr, eg.helper, eg.logger, eg.config.RobustAddressBestEffort) - if err != nil { - return nil, fmt.Errorf("error consolidating miner address: %w", err) - } - consolidatedMultiAddrs = append(consolidatedMultiAddrs, multiAddr) - } - controlAddresses = consolidatedControlAddrs - multiaddrs = consolidatedMultiAddrs } - value[KeyOwnerAddr] = ownerAddress - value[KeyWorkerAddr] = workerAddress - value[KeyControlAddrs] = controlAddresses - value[KeyMultiaddrs] = multiaddrs jsonData, err := json.Marshal(value) if err != nil { @@ -193,41 +137,33 @@ func (eg *eventGenerator) parseChangeWorkerAddress(tx *types.Transaction, tipset return nil, fmt.Errorf("error parsing params: %w", err) } - workerAddress, err := getItem[string](params, KeyNewWorker, false) - if err != nil { - return nil, fmt.Errorf("error parsing miner address: %w", err) - } - controlAddresses, err := getSlice[string](params, KeyNewControlAddrs, false) - if err != nil { - return nil, fmt.Errorf("error parsing miner address: %w", err) - } - if eg.config.ConsolidateRobustAddress { - addr, err := address.NewFromString(workerAddress) - if err != nil { - return nil, fmt.Errorf("error parsing miner address: %w", err) - } - workerAddress, err = actors.ConsolidateToRobustAddress(addr, eg.helper, eg.logger, eg.config.RobustAddressBestEffort) - if err != nil { - return nil, fmt.Errorf("error consolidating miner address: %w", err) - } - consolidatedControlAddrs := make([]string, 0, len(controlAddresses)) - for _, addrStr := range controlAddresses { - addr, err = address.NewFromString(addrStr) + workerAddress, _ := getItem[string](params, KeyNewWorker, true) + if workerAddress != "" { + parsedWorkerAddress, err := eg.consolidateAddress(workerAddress) if err != nil { - return nil, fmt.Errorf("error parsing miner address: %w", err) + eg.logger.Errorf("error consolidating worker address: %w", err) + } else { + params[KeyNewWorker] = parsedWorkerAddress } - controlAddress, err := actors.ConsolidateToRobustAddress(addr, eg.helper, eg.logger, eg.config.RobustAddressBestEffort) - if err != nil { - return nil, fmt.Errorf("error consolidating miner address: %w", err) + } + controlAddresses, _ := getSlice[string](params, KeyNewControlAddrs, true) + if len(controlAddresses) > 0 { + consolidatedControlAddresses := make([]string, 0, len(controlAddresses)) + for _, addrStr := range controlAddresses { + parsedControlAddress, err := eg.consolidateAddress(addrStr) + if err != nil { + eg.logger.Errorf("error consolidating control address: %w", err) + } else { + consolidatedControlAddresses = append(consolidatedControlAddresses, parsedControlAddress) + } + } + if len(consolidatedControlAddresses) == len(controlAddresses) { + params[KeyNewControlAddrs] = consolidatedControlAddresses } - consolidatedControlAddrs = append(consolidatedControlAddrs, controlAddress) } - - controlAddresses = consolidatedControlAddrs + value[KeyParams] = params } - value[KeyNewWorker] = workerAddress - value[KeyNewControlAddrs] = controlAddresses jsonData, err := json.Marshal(value) if err != nil { @@ -256,28 +192,24 @@ func (eg *eventGenerator) parseChangeMultiaddrs(tx *types.Transaction, tipsetCid return nil, fmt.Errorf("error parsing params: %w", err) } - multiaddrs, err := getSlice[string](params, KeyNewMultiAddrs, false) - if err != nil { - return nil, fmt.Errorf("error parsing miner address: %w", err) - } - if eg.config.ConsolidateRobustAddress { - consolidatedMultiAddrs := make([]string, 0, len(multiaddrs)) - for _, addrStr := range multiaddrs { - addr, err := address.NewFromString(addrStr) - if err != nil { - return nil, fmt.Errorf("error parsing miner address: %w", err) + multiaddrs, _ := getSlice[string](params, KeyNewMultiAddrs, true) + if len(multiaddrs) > 0 { + consolidatedMultiAddrs := make([]string, 0, len(multiaddrs)) + for _, addrStr := range multiaddrs { + parsedMultiaddr, err := eg.consolidateAddress(addrStr) + if err != nil { + eg.logger.Errorf("error consolidating multiaddr: %w", err) + } else { + consolidatedMultiAddrs = append(consolidatedMultiAddrs, parsedMultiaddr) + } } - multiAddr, err := actors.ConsolidateToRobustAddress(addr, eg.helper, eg.logger, eg.config.RobustAddressBestEffort) - if err != nil { - return nil, fmt.Errorf("error consolidating miner address: %w", err) + if len(consolidatedMultiAddrs) == len(multiaddrs) { + params[KeyNewMultiAddrs] = consolidatedMultiAddrs } - consolidatedMultiAddrs = append(consolidatedMultiAddrs, multiAddr) } - - multiaddrs = consolidatedMultiAddrs + value[KeyParams] = params } - value[KeyNewMultiAddrs] = multiaddrs jsonData, err := json.Marshal(value) if err != nil { @@ -306,22 +238,18 @@ func (eg *eventGenerator) parseChangeBeneficiary(tx *types.Transaction, tipsetCi return nil, fmt.Errorf("error parsing params: %w", err) } - beneficiary, err := getItem[string](params, KeyNewBeneficiary, false) - if err != nil { - return nil, fmt.Errorf("error parsing miner address: %w", err) - } - if eg.config.ConsolidateRobustAddress { - addr, err := address.NewFromString(beneficiary) - if err != nil { - return nil, fmt.Errorf("error parsing miner address: %w", err) - } - beneficiary, err = actors.ConsolidateToRobustAddress(addr, eg.helper, eg.logger, eg.config.RobustAddressBestEffort) - if err != nil { - return nil, fmt.Errorf("error consolidating miner address: %w", err) + beneficiary, _ := getItem[string](params, KeyNewBeneficiary, true) + if beneficiary != "" { + parsedBeneficiary, err := eg.consolidateAddress(beneficiary) + if err != nil { + eg.logger.Errorf("error consolidating beneficiary address: %w", err) + } else { + params[KeyNewBeneficiary] = parsedBeneficiary + } } + value[KeyParams] = params } - value[KeyNewBeneficiary] = beneficiary jsonData, err := json.Marshal(value) if err != nil { @@ -345,22 +273,17 @@ func (eg *eventGenerator) parseChangeOwnerAddress(tx *types.Transaction, tipsetC return nil, fmt.Errorf("error unmarshalling tx metadata: %w", err) } - ownerAddress, err := getItem[string](value, KeyParams, false) - if err != nil { - return nil, fmt.Errorf("error parsing params: %w", err) - } - if eg.config.ConsolidateRobustAddress { - addr, err := address.NewFromString(ownerAddress) - if err != nil { - return nil, fmt.Errorf("error parsing miner address: %w", err) - } - ownerAddress, err = actors.ConsolidateToRobustAddress(addr, eg.helper, eg.logger, eg.config.RobustAddressBestEffort) - if err != nil { - return nil, fmt.Errorf("error consolidating miner address: %w", err) + ownerAddress, _ := getItem[string](value, KeyParams, true) + if ownerAddress != "" { + parsedOwnerAddress, err := eg.consolidateAddress(ownerAddress) + if err != nil { + eg.logger.Errorf("error consolidating owner address: %w", err) + } else { + value[KeyParams] = parsedOwnerAddress + } } } - value[KeyParams] = ownerAddress jsonData, err := json.Marshal(value) if err != nil { @@ -376,3 +299,57 @@ func (eg *eventGenerator) parseChangeOwnerAddress(tx *types.Transaction, tipsetC TxTimestamp: tx.TxTimestamp, }, nil } + +func (eg *eventGenerator) consolidateConstructorAddresses(params map[string]interface{}) error { + ownerAddress, _ := getItem[string](params, KeyOwnerAddr, true) + if ownerAddress != "" { + parsedOwnerAddress, err := eg.consolidateAddress(ownerAddress) + if err != nil { + eg.logger.Errorf("error consolidating owner address: %w", err) + } else { + params[KeyOwnerAddr] = parsedOwnerAddress + } + } + + workerAddress, _ := getItem[string](params, KeyWorkerAddr, true) + if workerAddress != "" { + parsedWorkerAddress, err := eg.consolidateAddress(workerAddress) + if err != nil { + eg.logger.Errorf("error consolidating worker address: %w", err) + } else { + params[KeyWorkerAddr] = parsedWorkerAddress + } + } + controlAddresses, _ := getSlice[string](params, KeyControlAddrs, true) + if len(controlAddresses) > 0 { + consolidatedControlAddresses := make([]string, 0, len(controlAddresses)) + for _, addrStr := range controlAddresses { + parsedControlAddress, err := eg.consolidateAddress(addrStr) + if err != nil { + eg.logger.Errorf("error consolidating control address: %w", err) + } else { + consolidatedControlAddresses = append(consolidatedControlAddresses, parsedControlAddress) + } + } + if len(consolidatedControlAddresses) == len(controlAddresses) { + params[KeyControlAddrs] = consolidatedControlAddresses + } + } + multiaddrs, _ := getSlice[string](params, KeyMultiaddrs, true) + if len(multiaddrs) > 0 { + consolidatedMultiAddrs := make([]string, 0, len(multiaddrs)) + for _, addrStr := range multiaddrs { + parsedMultiaddr, err := eg.consolidateAddress(addrStr) + if err != nil { + eg.logger.Errorf("error consolidating multiaddr: %w", err) + } else { + consolidatedMultiAddrs = append(consolidatedMultiAddrs, parsedMultiaddr) + } + } + if len(consolidatedMultiAddrs) == len(multiaddrs) { + params[KeyMultiaddrs] = consolidatedMultiAddrs + } + } + + return nil +} diff --git a/tools/miner/sector.go b/tools/miner/sector.go index b3c1de6a..94608877 100644 --- a/tools/miner/sector.go +++ b/tools/miner/sector.go @@ -5,10 +5,8 @@ import ( "encoding/json" "fmt" - "github.com/filecoin-project/go-address" "github.com/filecoin-project/go-bitfield" "github.com/filecoin-project/go-state-types/manifest" - "github.com/zondax/fil-parser/actors" "github.com/zondax/fil-parser/parser" "github.com/zondax/fil-parser/tools" "github.com/zondax/fil-parser/types" @@ -284,15 +282,12 @@ func (eg *eventGenerator) parseProveCommitSectorsNI(_ context.Context, tx *types } if eg.config.ConsolidateRobustAddress { - sealerIDAddr, err := address.NewIDAddress(sealerID) + consolidatedSealerID, err := eg.consolidateIDAddress(sealerID) if err != nil { - return nil, fmt.Errorf("error parsing sealer id: %w", err) + eg.logger.Errorf("error consolidating sealer id: %w", err) + } else { + sectorActivation[KeySealerID] = consolidatedSealerID } - consolidatedSealerID, err := actors.ConsolidateToRobustAddress(sealerIDAddr, eg.helper, eg.logger, eg.config.RobustAddressBestEffort) - if err != nil { - return nil, fmt.Errorf("error consolidating sealer id: %w", err) - } - sectorActivation[KeySealerID] = consolidatedSealerID } jsonData, err := json.Marshal(sectorActivation) @@ -438,18 +433,17 @@ func (eg *eventGenerator) consolidatePieceActivationManifests(_ context.Context, if len(verifiedAllocationKey) > 0 { clientIDAddrStr, err := getItem[uint64](verifiedAllocationKey, KeyAddress, false) if err != nil { - return nil, fmt.Errorf("error parsing client id address: %w", err) - } - clientIDAddr, err := address.NewIDAddress(clientIDAddrStr) - if err != nil { - return nil, fmt.Errorf("error parsing client id address: %w", err) + eg.logger.Errorf("error parsing client id address: %w", err) + break } - consolidatedClientAddr, err := actors.ConsolidateToRobustAddress(clientIDAddr, eg.helper, eg.logger, eg.config.RobustAddressBestEffort) + consolidatedClientIDAddr, err := eg.consolidateIDAddress(clientIDAddrStr) if err != nil { - return nil, fmt.Errorf("error consolidating client id address: %w", err) + eg.logger.Errorf("error consolidating client id address: %w", err) + break } - verifiedAllocationKey[KeyAddress] = consolidatedClientAddr + verifiedAllocationKey[KeyAddress] = consolidatedClientIDAddr piece[KeyVerifiedAllocationKey] = verifiedAllocationKey + } dataActivationNotifications, err := getSlice[map[string]interface{}](piece, KeyNotify, true) @@ -461,22 +455,29 @@ func (eg *eventGenerator) consolidatePieceActivationManifests(_ context.Context, for _, notify := range dataActivationNotifications { addrStr, err := getItem[string](notify, KeyAddress, false) if err != nil { - return nil, fmt.Errorf("error parsing notify number: %w", err) + eg.logger.Errorf("error parsing notify number: %w", err) + break } - addr, err := address.NewFromString(addrStr) + consolidatedAddr, err := eg.consolidateAddress(addrStr) if err != nil { - return nil, fmt.Errorf("error parsing address: %w", err) - } - consolidatedAddr, err := actors.ConsolidateToRobustAddress(addr, eg.helper, eg.logger, eg.config.RobustAddressBestEffort) - if err != nil { - return nil, fmt.Errorf("error consolidating address: %w", err) + eg.logger.Errorf("error consolidating address: %w", err) + break } notify[KeyAddress] = consolidatedAddr parsedDataActivationNotifications = append(parsedDataActivationNotifications, notify) } - piece[KeyNotify] = parsedDataActivationNotifications + // only add the parsed data activation notifications if all the data activation notifications were parsed successfully + if len(parsedDataActivationNotifications) == len(dataActivationNotifications) { + piece[KeyNotify] = parsedDataActivationNotifications + } + } parsedPieces = append(parsedPieces, piece) } - return parsedPieces, nil + // only return the parsed pieces if all the pieces were parsed successfully + if len(parsedPieces) == len(pieces) { + return parsedPieces, nil + } + + return pieces, nil } diff --git a/tools/miner/utils.go b/tools/miner/utils.go index 0e9e597e..60b15009 100644 --- a/tools/miner/utils.go +++ b/tools/miner/utils.go @@ -4,7 +4,9 @@ import ( "fmt" "math/big" + "github.com/filecoin-project/go-address" "github.com/filecoin-project/go-state-types/abi" + "github.com/zondax/fil-parser/actors" "golang.org/x/exp/constraints" ) @@ -105,3 +107,27 @@ func sectorProofToBigInt(sectorProof int64) *big.Int { return big.NewInt(0).SetUint64(uint64(info.SectorSize)) } + +func (eg *eventGenerator) consolidateIDAddress(idAddress uint64) (string, error) { + addr, err := address.NewIDAddress(idAddress) + if err != nil { + return "", fmt.Errorf("error parsing id address: %w", err) + } + consolidatedIDAddress, err := actors.ConsolidateToRobustAddress(addr, eg.helper, eg.logger, eg.config.RobustAddressBestEffort) + if err != nil { + return "", fmt.Errorf("error consolidating id address: %w", err) + } + return consolidatedIDAddress, nil +} + +func (eg *eventGenerator) consolidateAddress(addrStr string) (string, error) { + addr, err := address.NewFromString(addrStr) + if err != nil { + return "", fmt.Errorf("error parsing id address: %w", err) + } + consolidatedAddress, err := actors.ConsolidateToRobustAddress(addr, eg.helper, eg.logger, eg.config.RobustAddressBestEffort) + if err != nil { + return "", fmt.Errorf("error consolidating address: %w", err) + } + return consolidatedAddress, nil +} diff --git a/tools/multisig/multisig.go b/tools/multisig/multisig.go index b6bb06c7..ce250d48 100644 --- a/tools/multisig/multisig.go +++ b/tools/multisig/multisig.go @@ -221,21 +221,19 @@ func (eg *eventGenerator) createMultisigInfo(ctx context.Context, tx *types.Tran if !ok { return nil, fmt.Errorf("parsedMetadata is not a map[string]interface{}") } - signerAddrStr, ok := signerData[metadataSigner].(string) - if !ok { - return nil, fmt.Errorf("signer address not found in parsedMetadata") - } - signerAddr, err := address.NewFromString(signerAddrStr) - if err != nil { - return nil, fmt.Errorf("address.NewFromString(): %s", err) - } - signerAddrStr, err = actors.ConsolidateToRobustAddress(signerAddr, eg.helper, eg.logger, eg.config.RobustAddressBestEffort) - if err != nil { - return nil, fmt.Errorf("actors.ConsolidateToRobustAddress(%s): %s", signerAddrStr, err) + if ok { + signerAddr, err := address.NewFromString(signerAddrStr) + if err != nil { + return nil, fmt.Errorf("address.NewFromString(%s): %s", signerAddrStr, err) + } + signerAddrStr, err = actors.ConsolidateToRobustAddress(signerAddr, eg.helper, eg.logger, eg.config.RobustAddressBestEffort) + if err != nil { + return nil, fmt.Errorf("actors.ConsolidateToRobustAddress(%s): %s", signerAddrStr, err) + } + signerData[metadataSigner] = signerAddrStr + parsedMetadata = signerData } - signerData[metadataSigner] = signerAddrStr - parsedMetadata = signerData } if isConstructor(tx.TxType) { @@ -244,23 +242,27 @@ func (eg *eventGenerator) createMultisigInfo(ctx context.Context, tx *types.Tran return nil, fmt.Errorf("parsedMetadata is not a map[string]interface{}") } signers, ok := constructorData[metadataSigners].([]string) - if !ok { - return nil, fmt.Errorf("signers is not a []string") - } - consolidatedSigners := make([]string, 0, len(signers)) - for _, signer := range signers { - addr, err := address.NewFromString(signer) - if err != nil { - return nil, fmt.Errorf("address.NewFromString(%s): %s", signer, err) + if ok { + consolidatedSigners := make([]string, 0, len(signers)) + for _, signer := range signers { + addr, err := address.NewFromString(signer) + if err != nil { + eg.logger.Errorf("address.NewFromString(%s): %s", signer, err) + break + } + robustAddr, err := actors.ConsolidateToRobustAddress(addr, eg.helper, eg.logger, eg.config.RobustAddressBestEffort) + if err != nil { + eg.logger.Errorf("actors.ConsolidateToRobustAddress(%s): %s", addr, err) + break + } + consolidatedSigners = append(consolidatedSigners, robustAddr) } - robustAddr, err := actors.ConsolidateToRobustAddress(addr, eg.helper, eg.logger, eg.config.RobustAddressBestEffort) - if err != nil { - return nil, fmt.Errorf("actors.ConsolidateToRobustAddress(%s): %s", addr, err) + // only add the consolidated signers if all the signers were consolidated successfully + if len(consolidatedSigners) == len(signers) { + constructorData[metadataSigners] = consolidatedSigners + parsedMetadata = constructorData } - consolidatedSigners = append(consolidatedSigners, robustAddr) } - constructorData[metadataSigners] = consolidatedSigners - parsedMetadata = constructorData } }