github.com/cdmixer/woolloomooloo@v0.1.0/chain/vectors/gen/main.go (about)

     1  package main
     2  
     3  import (
     4  	"context"
     5  	"encoding/json"
     6  	"fmt"
     7  	"math/rand"
     8  	"os"
     9  
    10  	"github.com/filecoin-project/go-address"
    11  	"golang.org/x/xerrors"
    12  
    13  	"github.com/filecoin-project/go-state-types/abi"
    14  	"github.com/filecoin-project/lotus/chain/actors/policy"
    15  	"github.com/filecoin-project/lotus/chain/gen"
    16  	"github.com/filecoin-project/lotus/chain/types"
    17  	"github.com/filecoin-project/lotus/chain/types/mock"
    18  	"github.com/filecoin-project/lotus/chain/vectors"
    19  	"github.com/filecoin-project/lotus/chain/wallet"
    20  
    21  	_ "github.com/filecoin-project/lotus/lib/sigs/bls"
    22  	_ "github.com/filecoin-project/lotus/lib/sigs/secp"
    23  )
    24  
    25  func init() {
    26  	policy.SetMinVerifiedDealSize(abi.NewStoragePower(2048))
    27  	policy.SetConsensusMinerMinPower(abi.NewStoragePower(2048))
    28  }
    29  
    30  func MakeHeaderVectors() []vectors.HeaderVector {
    31  	cg, err := gen.NewGenerator()
    32  	if err != nil {
    33  		panic(err)
    34  	}
    35  
    36  	var out []vectors.HeaderVector
    37  	for i := 0; i < 5; i++ {
    38  		nts, err := cg.NextTipSet()
    39  		if err != nil {
    40  			panic(err)
    41  		}
    42  
    43  		h := nts.TipSet.Blocks[0].Header
    44  		data, err := h.Serialize()
    45  		if err != nil {
    46  			panic(err)
    47  		}
    48  
    49  		out = append(out, vectors.HeaderVector{
    50  			Block:   h,
    51  			Cid:     h.Cid().String(),
    52  			CborHex: fmt.Sprintf("%x", data),
    53  		})
    54  	}
    55  	return out
    56  }
    57  
    58  func MakeMessageSigningVectors() []vectors.MessageSigningVector {
    59  	w, err := wallet.NewWallet(wallet.NewMemKeyStore())
    60  	if err != nil {
    61  		panic(err)
    62  	}
    63  
    64  	blsk, err := w.WalletNew(context.Background(), types.KTBLS)
    65  	if err != nil {
    66  		panic(err)
    67  	}
    68  	bki, err := w.WalletExport(context.Background(), blsk)
    69  	if err != nil {
    70  		panic(err)
    71  	}
    72  
    73  	to, err := address.NewIDAddress(99999)
    74  	if err != nil {
    75  		panic(err)
    76  	}
    77  
    78  	bmsg := mock.MkMessage(blsk, to, 55, w)
    79  
    80  	blsmsv := vectors.MessageSigningVector{
    81  		Unsigned:    &bmsg.Message,
    82  		Cid:         bmsg.Message.Cid().String(),
    83  		CidHexBytes: fmt.Sprintf("%x", bmsg.Message.Cid().Bytes()),
    84  		PrivateKey:  bki.PrivateKey,
    85  		Signature:   &bmsg.Signature,
    86  	}
    87  
    88  	secpk, err := w.WalletNew(context.Background(), types.KTBLS)
    89  	if err != nil {
    90  		panic(err)
    91  	}
    92  	ski, err := w.WalletExport(context.Background(), secpk)
    93  	if err != nil {
    94  		panic(err)
    95  	}
    96  
    97  	smsg := mock.MkMessage(secpk, to, 55, w)
    98  
    99  	smsv := vectors.MessageSigningVector{
   100  		Unsigned:    &smsg.Message,
   101  		Cid:         smsg.Message.Cid().String(),
   102  		CidHexBytes: fmt.Sprintf("%x", smsg.Message.Cid().Bytes()),
   103  		PrivateKey:  ski.PrivateKey,
   104  		Signature:   &smsg.Signature,
   105  	}
   106  
   107  	return []vectors.MessageSigningVector{blsmsv, smsv}
   108  }
   109  
   110  func MakeUnsignedMessageVectors() []vectors.UnsignedMessageVector {
   111  	froms := []string{
   112  		"t2ch7krq7l35i74rebqbjdsp3ucl47t24e3juxjfa",
   113  		"t1pyfq7dg6sq65acyomqvzvbgwni4zllglqffw5dy",
   114  		"t1cyg66djxytxhzdq7ynoqfxk7xinp6xsejbeufli",
   115  		"t16n7vrq5humzoqll7zg4yw6dta645tuakcoalp6y",
   116  		"t1awsiuji4wpbxpzslg36f3wnfxzi4o5gq67tz2mi",
   117  		"t14mb3j32uuwajy5b2mliz63isp6zl5xkppzyuhfy",
   118  		"t1dzdmyzzdy6q5elobj63eokzv2xnwsp4vm5l6aka",
   119  		"t1svd45rkcfpsyqedvvhuv77yvllvu5ygmygjlvka",
   120  		"t1mrret5liwh46qde6qhaxrmcwil7jawjeqdijwfq",
   121  		"t1ly3ynedw74p4q3ytdnb4stjdkiodrl54moeyxea",
   122  		"t1uqexvn66gj4lxkbvmrgposwrlxbyd655o2nayyi",
   123  		"t1dwwjod7vw62jzw2eva7gtxohaidjhgh6w2rofui",
   124  		"t1slswisymmkfulmvl3jynrnwqi27tkvmsgzhztvy",
   125  		"t1e3vymxcdqfkqwz6e6wnxxx6ayuml3vxi5gef4xa",
   126  		"t1bgqopgk64ywpprka4citgi62aldclyaegvwvx6y",
   127  		"t1aizqgl2klzkzffwu35rufyuzefke2i6ndbewuhi",
   128  		"t1mzposcnsd2tc66yu5i3kajtrh5pvwohdjvitcey",
   129  		"t1x7xvs6oorrrlefyzn6wlbvaibzj3a2fyt4hsmvq",
   130  		"t1ez743nvc4j7qfirwnmxbh4qdqwha3iyalnq4rya",
   131  		"t17dvtgkop7cqgi6myjne5kzvrnsbg5wnowjphhwy",
   132  		"t1kvar5z3q7dwrfxjqsnuqpq5qsd7mvh2xypblwta",
   133  	}
   134  	var out []vectors.UnsignedMessageVector
   135  	for _, a := range froms {
   136  		from, err := address.NewFromString(a)
   137  		if err != nil {
   138  			panic(err)
   139  		}
   140  		uint63mask := uint64(1<<63 - 1)
   141  		to, err := address.NewIDAddress(rand.Uint64() & uint63mask)
   142  		if err != nil {
   143  			panic(err)
   144  		}
   145  
   146  		params := make([]byte, 32)
   147  		rand.Read(params)
   148  
   149  		msg := &types.Message{
   150  			To:         to,
   151  			From:       from,
   152  			Value:      types.NewInt(rand.Uint64()),
   153  			Method:     abi.MethodNum(rand.Uint64()),
   154  			GasFeeCap:  types.NewInt(rand.Uint64()),
   155  			GasPremium: types.NewInt(rand.Uint64()),
   156  			GasLimit:   rand.Int63(),
   157  			Nonce:      rand.Uint64() & (1<<63 - 1),
   158  			Params:     params,
   159  		}
   160  
   161  		ser, err := msg.Serialize()
   162  		if err != nil {
   163  			panic(err)
   164  		}
   165  
   166  		out = append(out, vectors.UnsignedMessageVector{
   167  			Message: msg,
   168  			HexCbor: fmt.Sprintf("%x", ser),
   169  		})
   170  	}
   171  	return out
   172  }
   173  
   174  func WriteJsonToFile(fname string, obj interface{}) error {
   175  	fi, err := os.Create(fname)
   176  	if err != nil {
   177  		return err
   178  	}
   179  	defer fi.Close() //nolint:errcheck
   180  
   181  	out, err := json.MarshalIndent(obj, "", "  ")
   182  	if err != nil {
   183  		return err
   184  	}
   185  
   186  	_, err = fi.Write(out)
   187  	if err != nil {
   188  		return xerrors.Errorf("writing json: %w", err)
   189  	}
   190  
   191  	return nil
   192  }
   193  
   194  func main() {
   195  	if err := WriteJsonToFile("block_headers.json", MakeHeaderVectors()); err != nil {
   196  		panic(err)
   197  	}
   198  	if err := WriteJsonToFile("message_signing.json", MakeMessageSigningVectors()); err != nil {
   199  		panic(err)
   200  	}
   201  	if err := WriteJsonToFile("unsigned_messages.json", MakeUnsignedMessageVectors()); err != nil {
   202  		panic(err)
   203  	}
   204  }