log: fix the wrong logs (#79)

common/prove/add_liquidity.go

@@ -28,20 +28,20 @@ import (
 func (w *WitnessHelper) constructAddLiquidityCryptoTx(cryptoTx *CryptoTx, oTx *Tx) (*CryptoTx, error) {
 	txInfo, err := types.ParseAddLiquidityTxInfo(oTx.TxInfo)
 	if err != nil {
-		logx.Errorf("[ConstructAddLiquidityCryptoTx] unable to parse register zns tx info:%s", err.Error())
+		logx.Errorf("unable to parse add liquidity tx info:%s", err.Error())
 		return nil, err
 	}
 	cryptoTxInfo, err := ToCryptoAddLiquidityTx(txInfo)
 	if err != nil {
-		logx.Errorf("[ConstructAddLiquidityCryptoTx] unable to convert to crypto register zns tx: %s", err.Error())
+		logx.Errorf("unable to convert to crypto add liquidity tx: %s", err.Error())
 		return nil, err
 	}
 	cryptoTx.AddLiquidityTxInfo = cryptoTxInfo
 	cryptoTx.ExpiredAt = txInfo.ExpiredAt
 	cryptoTx.Signature = new(eddsa.Signature)
 	_, err = cryptoTx.Signature.SetBytes(txInfo.Sig)
 	if err != nil {
-		logx.Errorf("[ConstructAddLiquidityCryptoTx] invalid sig bytes: %s", err.Error())
+		logx.Errorf("invalid sig bytes: %s", err.Error())
 		return nil, err
 	}
 	return cryptoTx, nil
@@ -50,32 +50,32 @@ func (w *WitnessHelper) constructAddLiquidityCryptoTx(cryptoTx *CryptoTx, oTx *T
 func ToCryptoAddLiquidityTx(txInfo *types.AddLiquidityTxInfo) (info *CryptoAddLiquidityTx, err error) {
 	packedAAmount, err := common.ToPackedAmount(txInfo.AssetAAmount)
 	if err != nil {
-		logx.Errorf("[ToCryptoAddLiquidityTx] unable to convert to packed amount: %s", err.Error())
+		logx.Errorf("unable to convert to packed amount: %s", err.Error())
 		return nil, err
 	}
 	packedBAmount, err := common.ToPackedAmount(txInfo.AssetBAmount)
 	if err != nil {
-		logx.Errorf("[ToCryptoAddLiquidityTx] unable to convert to packed amount: %s", err.Error())
+		logx.Errorf("unable to convert to packed amount: %s", err.Error())
 		return nil, err
 	}
 	packedLpAmount, err := common.ToPackedAmount(txInfo.LpAmount)
 	if err != nil {
-		logx.Errorf("[ToCryptoAddLiquidityTx] unable to convert to packed amount: %s", err.Error())
+		logx.Errorf("unable to convert to packed amount: %s", err.Error())
 		return nil, err
 	}
 	packedTreasuryAmount, err := common.ToPackedAmount(txInfo.TreasuryAmount)
 	if err != nil {
-		logx.Errorf("[ToCryptoAddLiquidityTx] unable to convert to packed amount: %s", err.Error())
+		logx.Errorf("unable to convert to packed amount: %s", err.Error())
 		return nil, err
 	}
 	packedKLast, err := common.ToPackedAmount(txInfo.KLast)
 	if err != nil {
-		logx.Errorf("[ToCryptoAddLiquidityTx] unable to convert to packed amount: %s", err.Error())
+		logx.Errorf("unable to convert to packed amount: %s", err.Error())
 		return nil, err
 	}
 	packedFee, err := common.ToPackedFee(txInfo.GasFeeAssetAmount)
 	if err != nil {
-		logx.Errorf("[ToCryptoAddLiquidityTx] unable to convert to packed fee: %s", err.Error())
+		logx.Errorf("unable to convert to packed fee: %s", err.Error())
 		return nil, err
 	}
 	info = &CryptoAddLiquidityTx{

common/prove/atomic_match.go

@@ -28,20 +28,20 @@ import (
 func (w *WitnessHelper) constructAtomicMatchCryptoTx(cryptoTx *CryptoTx, oTx *Tx) (*CryptoTx, error) {
 	txInfo, err := types.ParseAtomicMatchTxInfo(oTx.TxInfo)
 	if err != nil {
-		logx.Errorf("[ConstructAtomicMatchCryptoTx] unable to parse register zns tx info:%s", err.Error())
+		logx.Errorf("unable to parse atomic match tx info:%s", err.Error())
 		return nil, err
 	}
 	cryptoTxInfo, err := ToCryptoAtomicMatchTx(txInfo)
 	if err != nil {
-		logx.Errorf("[ConstructAtomicMatchCryptoTx] unable to convert to crypto register zns tx: %s", err.Error())
+		logx.Errorf("unable to convert to crypto atomic match tx: %s", err.Error())
 		return nil, err
 	}
 	cryptoTx.AtomicMatchTxInfo = cryptoTxInfo
 	cryptoTx.ExpiredAt = txInfo.ExpiredAt
 	cryptoTx.Signature = new(eddsa.Signature)
 	_, err = cryptoTx.Signature.SetBytes(txInfo.Sig)
 	if err != nil {
-		logx.Errorf("[ConstructAtomicMatchCryptoTx] invalid sig bytes: %s", err.Error())
+		logx.Errorf("invalid sig bytes: %s", err.Error())
 		return nil, err
 	}
 	return cryptoTx, nil
@@ -50,22 +50,22 @@ func (w *WitnessHelper) constructAtomicMatchCryptoTx(cryptoTx *CryptoTx, oTx *Tx
 func ToCryptoAtomicMatchTx(txInfo *types.AtomicMatchTxInfo) (info *CryptoAtomicMatchTx, err error) {
 	packedFee, err := common.ToPackedFee(txInfo.GasFeeAssetAmount)
 	if err != nil {
-		logx.Errorf("[ToCryptoSwapTx] unable to convert to packed fee: %s", err.Error())
+		logx.Errorf("unable to convert to packed fee: %s", err.Error())
 		return nil, err
 	}
 	packedAmount, err := common.ToPackedAmount(txInfo.BuyOffer.AssetAmount)
 	if err != nil {
-		logx.Errorf("[ToCryptoSwapTx] unable to convert to packed amount: %s", err.Error())
+		logx.Errorf("unable to convert to packed amount: %s", err.Error())
 		return nil, err
 	}
 	packedCreatorAmount, err := common.ToPackedAmount(txInfo.CreatorAmount)
 	if err != nil {
-		logx.Errorf("[ToCryptoSwapTx] unable to convert to packed amount: %s", err.Error())
+		logx.Errorf("unable to convert to packed amount: %s", err.Error())
 		return nil, err
 	}
 	packedTreasuryAmount, err := common.ToPackedAmount(txInfo.TreasuryAmount)
 	if err != nil {
-		logx.Errorf("[ToCryptoSwapTx] unable to convert to packed amount: %s", err.Error())
+		logx.Errorf("unable to convert to packed amount: %s", err.Error())
 		return nil, err
 	}
 	buySig := new(eddsa.Signature)

common/prove/cancel_offer.go

@@ -28,20 +28,20 @@ import (
 func (w *WitnessHelper) constructCancelOfferCryptoTx(cryptoTx *CryptoTx, oTx *Tx) (*CryptoTx, error) {
 	txInfo, err := types.ParseCancelOfferTxInfo(oTx.TxInfo)
 	if err != nil {
-		logx.Errorf("[ConstructCancelOfferCryptoTx] unable to parse register zns tx info:%s", err.Error())
+		logx.Errorf("unable to parse cancel offer tx info:%s", err.Error())
 		return nil, err
 	}
 	cryptoTxInfo, err := ToCryptoCancelOfferTx(txInfo)
 	if err != nil {
-		logx.Errorf("[ConstructCancelOfferCryptoTx] unable to convert to crypto register zns tx: %s", err.Error())
+		logx.Errorf("unable to convert to crypto cancel offer tx: %s", err.Error())
 		return nil, err
 	}
 	cryptoTx.CancelOfferTxInfo = cryptoTxInfo
 	cryptoTx.ExpiredAt = txInfo.ExpiredAt
 	cryptoTx.Signature = new(eddsa.Signature)
 	_, err = cryptoTx.Signature.SetBytes(txInfo.Sig)
 	if err != nil {
-		logx.Errorf("[ConstructCancelOfferCryptoTx] invalid sig bytes: %s", err.Error())
+		logx.Errorf("invalid sig bytes: %s", err.Error())
 		return nil, err
 	}
 	return cryptoTx, nil
@@ -50,7 +50,7 @@ func (w *WitnessHelper) constructCancelOfferCryptoTx(cryptoTx *CryptoTx, oTx *Tx
 func ToCryptoCancelOfferTx(txInfo *types.CancelOfferTxInfo) (info *CryptoCancelOfferTx, err error) {
 	packedFee, err := common.ToPackedFee(txInfo.GasFeeAssetAmount)
 	if err != nil {
-		logx.Errorf("[ToCryptoSwapTx] unable to convert to packed fee: %s", err.Error())
+		logx.Errorf("unable to convert to packed fee: %s", err.Error())
 		return nil, err
 	}
 	info = &CryptoCancelOfferTx{

common/prove/create_collection.go

@@ -28,20 +28,20 @@ import (
 func (w *WitnessHelper) constructCreateCollectionCryptoTx(cryptoTx *CryptoTx, oTx *Tx) (*CryptoTx, error) {
 	txInfo, err := types.ParseCreateCollectionTxInfo(oTx.TxInfo)
 	if err != nil {
-		logx.Errorf("[ConstructCreateCollectionCryptoTx] unable to parse register zns tx info:%s", err.Error())
+		logx.Errorf("unable to parse create collection tx info:%s", err.Error())
 		return nil, err
 	}
 	cryptoTxInfo, err := ToCryptoCreateCollectionTx(txInfo)
 	if err != nil {
-		logx.Errorf("[ConstructCreateCollectionCryptoTx] unable to convert to crypto register zns tx: %s", err.Error())
+		logx.Errorf("unable to convert to crypto create collection tx: %s", err.Error())
 		return nil, err
 	}
 	cryptoTx.CreateCollectionTxInfo = cryptoTxInfo
 	cryptoTx.ExpiredAt = txInfo.ExpiredAt
 	cryptoTx.Signature = new(eddsa.Signature)
 	_, err = cryptoTx.Signature.SetBytes(txInfo.Sig)
 	if err != nil {
-		logx.Errorf("[ConstructCreateCollectionCryptoTx] invalid sig bytes: %s", err.Error())
+		logx.Errorf("invalid sig bytes: %s", err.Error())
 		return nil, err
 	}
 	return cryptoTx, nil
@@ -50,7 +50,7 @@ func (w *WitnessHelper) constructCreateCollectionCryptoTx(cryptoTx *CryptoTx, oT
 func ToCryptoCreateCollectionTx(txInfo *types.CreateCollectionTxInfo) (info *CryptoCreateCollectionTx, err error) {
 	packedFee, err := common.ToPackedFee(txInfo.GasFeeAssetAmount)
 	if err != nil {
-		logx.Errorf("[ToCryptoSwapTx] unable to convert to packed fee: %s", err.Error())
+		logx.Errorf("unable to convert to packed fee: %s", err.Error())
 		return nil, err
 	}
 	info = &CryptoCreateCollectionTx{

common/prove/create_pair.go

@@ -28,12 +28,12 @@ import (
 func (w *WitnessHelper) constructCreatePairCryptoTx(cryptoTx *CryptoTx, oTx *Tx) (*CryptoTx, error) {
 	txInfo, err := types.ParseCreatePairTxInfo(oTx.TxInfo)
 	if err != nil {
-		logx.Errorf("[ConstructCreatePairCryptoTx] unable to parse register zns tx info:%s", err.Error())
+		logx.Errorf("unable to parse create pair tx info:%s", err.Error())
 		return nil, err
 	}
 	cryptoTxInfo, err := ToCryptoCreatePairTx(txInfo)
 	if err != nil {
-		logx.Errorf("[ConstructCreatePairCryptoTx] unable to convert to crypto register zns tx: %s", err.Error())
+		logx.Errorf("unable to convert to crypto create pair tx: %s", err.Error())
 		return nil, err
 	}
 	cryptoTx.CreatePairTxInfo = cryptoTxInfo

common/prove/deposit.go

@@ -28,12 +28,12 @@ import (
 func (w *WitnessHelper) constructDepositCryptoTx(cryptoTx *CryptoTx, oTx *Tx) (*CryptoTx, error) {
 	txInfo, err := types.ParseDepositTxInfo(oTx.TxInfo)
 	if err != nil {
-		logx.Errorf("[ConstructDepositCryptoTx] unable to parse register zns tx info:%s", err.Error())
+		logx.Errorf("unable to parse deposit tx info:%s", err.Error())
 		return nil, err
 	}
 	cryptoTxInfo, err := ToCryptoDepositTx(txInfo)
 	if err != nil {
-		logx.Errorf("[ConstructDepositCryptoTx] unable to convert to crypto register zns tx: %s", err.Error())
+		logx.Errorf("unable to convert to crypto deposit tx: %s", err.Error())
 		return nil, err
 	}
 	cryptoTx.DepositTxInfo = cryptoTxInfo

common/prove/deposit_nft.go

@@ -28,12 +28,12 @@ import (
 func (w *WitnessHelper) constructDepositNftCryptoTx(cryptoTx *CryptoTx, oTx *Tx) (*CryptoTx, error) {
 	txInfo, err := types.ParseDepositNftTxInfo(oTx.TxInfo)
 	if err != nil {
-		logx.Errorf("[ConstructDepositNftCryptoTx] unable to parse register zns tx info:%s", err.Error())
+		logx.Errorf("unable to parse deposit nft tx info:%s", err.Error())
 		return nil, err
 	}
 	cryptoTxInfo, err := ToCryptoDepositNftTx(txInfo)
 	if err != nil {
-		logx.Errorf("[ConstructDepositNftCryptoTx] unable to convert to crypto register zns tx: %s", err.Error())
+		logx.Errorf("unable to convert to crypto deposit nft tx: %s", err.Error())
 		return nil, err
 	}
 	cryptoTx.DepositNftTxInfo = cryptoTxInfo

common/prove/fullexit.go

@@ -28,12 +28,12 @@ import (
 func (w *WitnessHelper) constructFullExitCryptoTx(cryptoTx *CryptoTx, oTx *Tx) (*CryptoTx, error) {
 	txInfo, err := types.ParseFullExitTxInfo(oTx.TxInfo)
 	if err != nil {
-		logx.Errorf("[ConstructFullExitCryptoTx] unable to parse register zns tx info:%s", err.Error())
+		logx.Errorf("unable to parse register zns tx info:%s", err.Error())
 		return nil, err
 	}
 	cryptoTxInfo, err := ToCryptoFullExitTx(txInfo)
 	if err != nil {
-		logx.Errorf("[ConstructFullExitCryptoTx] unable to convert to crypto register zns tx: %s", err.Error())
+		logx.Errorf("unable to convert to crypto register zns tx: %s", err.Error())
 		return nil, err
 	}
 	cryptoTx.FullExitTxInfo = cryptoTxInfo

common/prove/fullexit_nft.go

@@ -28,12 +28,12 @@ import (
 func (w *WitnessHelper) constructFullExitNftCryptoTx(cryptoTx *CryptoTx, oTx *Tx) (*CryptoTx, error) {
 	txInfo, err := types.ParseFullExitNftTxInfo(oTx.TxInfo)
 	if err != nil {
-		logx.Errorf("[ConstructFullExitNftCryptoTx] unable to parse register zns tx info:%s", err.Error())
+		logx.Errorf("unable to parse register zns tx info:%s", err.Error())
 		return nil, err
 	}
 	cryptoTxInfo, err := ToCryptoFullExitNftTx(txInfo)
 	if err != nil {
-		logx.Errorf("[ConstructFullExitNftCryptoTx] unable to convert to crypto register zns tx: %s", err.Error())
+		logx.Errorf("unable to convert to crypto register zns tx: %s", err.Error())
 		return nil, err
 	}
 	cryptoTx.FullExitNftTxInfo = cryptoTxInfo

common/prove/keys.go

@@ -52,7 +52,7 @@ func GenerateProof(
 	// verify CryptoBlock
 	blockWitness, err := cryptoBlock.SetBlockWitness(cBlock)
 	if err != nil {
-		logx.Errorf("[GenerateProof] unable to set block witness: %s", err.Error())
+		logx.Errorf("unable to set block witness: %s", err.Error())
 		return proof, err
 	}
 	var verifyWitness cryptoBlock.BlockConstraints
@@ -61,27 +61,27 @@ func GenerateProof(
 	verifyWitness.BlockCommitment = cBlock.BlockCommitment
 	witness, err := frontend.NewWitness(&blockWitness, ecc.BN254)
 	if err != nil {
-		logx.Errorf("[GenerateProof] unable to generate new witness: %s", err.Error())
+		logx.Errorf("unable to generate new witness: %s", err.Error())
 		return proof, err
 	}
 	vWitness, err := frontend.NewWitness(&verifyWitness, ecc.BN254, frontend.PublicOnly())
 	if err != nil {
-		logx.Errorf("[GenerateProof] unable to generate new witness: %s", err.Error())
+		logx.Errorf("unable to generate new witness: %s", err.Error())
 		return proof, err
 	}
 	elapse := time.Now()
 	logx.Info("start proving")
 	proof, err = groth16.Prove(r1cs, provingKey, witness, backend.WithHints(std.Keccak256, std.ComputeSLp))
 	if err != nil {
-		logx.Errorf("[GenerateProof] unable to make a proof: %s", err.Error())
+		logx.Errorf("unable to make a proof: %s", err.Error())
 		return proof, err
 	}
 	fmt.Println("finish proving: ", time.Since(elapse))
 	elapse = time.Now()
 	logx.Info("start verifying")
 	err = groth16.Verify(proof, verifyingKey, vWitness)
 	if err != nil {
-		logx.Errorf("[GenerateProof] invalid block proof: %s", err.Error())
+		logx.Errorf("invalid block proof: %s", err.Error())
 		return proof, err
 	}
 
@@ -101,7 +101,7 @@ func FormatProof(oProof groth16.Proof, oldRoot, newRoot, commitment []byte) (pro
 	var buf bytes.Buffer
 	_, err = oProof.WriteRawTo(&buf)
 	if err != nil {
-		logx.Errorf("[FormatProof] unable to format proof: %s", err.Error())
+		logx.Errorf("unable to format proof: %s", err.Error())
 		return nil, err
 	}
 	proofBytes := buf.Bytes()

common/prove/mint_nft.go

@@ -29,20 +29,20 @@ import (
 func (w *WitnessHelper) constructMintNftCryptoTx(cryptoTx *CryptoTx, oTx *Tx) (*CryptoTx, error) {
 	txInfo, err := types.ParseMintNftTxInfo(oTx.TxInfo)
 	if err != nil {
-		logx.Errorf("[ConstructMintNftCryptoTx] unable to parse register zns tx info:%s", err.Error())
+		logx.Errorf("unable to parse mint nft tx info:%s", err.Error())
 		return nil, err
 	}
 	cryptoTxInfo, err := ToCryptoMintNftTx(txInfo)
 	if err != nil {
-		logx.Errorf("[ConstructMintNftCryptoTx] unable to convert to crypto register zns tx: %s", err.Error())
+		logx.Errorf("unable to convert to crypto mint nft tx: %s", err.Error())
 		return nil, err
 	}
 	cryptoTx.MintNftTxInfo = cryptoTxInfo
 	cryptoTx.ExpiredAt = txInfo.ExpiredAt
 	cryptoTx.Signature = new(eddsa.Signature)
 	_, err = cryptoTx.Signature.SetBytes(txInfo.Sig)
 	if err != nil {
-		logx.Errorf("[ConstructMintNftCryptoTx] invalid sig bytes: %s", err.Error())
+		logx.Errorf("invalid sig bytes: %s", err.Error())
 		return nil, err
 	}
 	return cryptoTx, nil
@@ -51,7 +51,7 @@ func (w *WitnessHelper) constructMintNftCryptoTx(cryptoTx *CryptoTx, oTx *Tx) (*
 func ToCryptoMintNftTx(txInfo *types.MintNftTxInfo) (info *CryptoMintNftTx, err error) {
 	packedFee, err := common2.ToPackedFee(txInfo.GasFeeAssetAmount)
 	if err != nil {
-		logx.Errorf("[ToCryptoSwapTx] unable to convert to packed fee: %s", err.Error())
+		logx.Errorf("unable to convert to packed fee: %s", err.Error())
 		return nil, err
 	}
 	info = &CryptoMintNftTx{

common/prove/register_zns.go

@@ -31,12 +31,12 @@ import (
 func (w *WitnessHelper) constructRegisterZnsCryptoTx(cryptoTx *CryptoTx, oTx *Tx) (*CryptoTx, error) {
 	txInfo, err := types.ParseRegisterZnsTxInfo(oTx.TxInfo)
 	if err != nil {
-		logx.Errorf("[ConstructRegisterZnsCryptoTx] unable to parse register zns tx info:%s", err.Error())
+		logx.Errorf("unable to parse register zns tx info:%s", err.Error())
 		return nil, err
 	}
 	cryptoTxInfo, err := ToCryptoRegisterZnsTx(txInfo)
 	if err != nil {
-		logx.Errorf("[ConstructRegisterZnsCryptoTx] unable to convert to crypto register zns tx: %s", err.Error())
+		logx.Errorf("unable to convert to crypto register zns tx: %s", err.Error())
 		return nil, err
 	}
 	cryptoTx.Signature = std.EmptySignature()
@@ -51,7 +51,7 @@ func ToCryptoRegisterZnsTx(txInfo *legendTxTypes.RegisterZnsTxInfo) (info *Crypt
 	copy(accountName[:], realName)
 	pk, err := common.ParsePubKey(txInfo.PubKey)
 	if err != nil {
-		logx.Errorf("[ToCryptoRegisterZnsTx] unable to parse pub key:%s", err.Error())
+		logx.Errorf("unable to parse pub key:%s", err.Error())
 		return nil, err
 	}
 	info = &CryptoRegisterZnsTx{