/
lotus.go
109 lines (93 loc) · 3.16 KB
/
lotus.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
package cmd
import (
"context"
"fmt"
"log"
"net/http"
"os"
"reflect"
"strings"
"github.com/filecoin-project/go-address"
jsonrpc "github.com/filecoin-project/go-jsonrpc"
"github.com/filecoin-project/go-state-types/abi"
lotusapi "github.com/filecoin-project/lotus/api"
"github.com/filecoin-project/lotus/chain/actors/builtin"
builtin1 "github.com/filecoin-project/specs-actors/v7/actors/builtin"
util "github.com/glifio/graph/internal/utils"
"github.com/spf13/cobra"
)
func init() {
lotusCmd.Flags().StringVarP(&flag_address, "address", "a", "", "The address of the txn")
lotusCmd.Flags().Uint64VarP(&flag_method, "method", "m", 0, "The method used")
rootCmd.AddCommand(lotusCmd)
}
var lotusCmd = &cobra.Command{
Use: "lotus",
Short: "Test lotus",
Long: `Test lotus`,
Run: func(cmd *cobra.Command, args []string) {
fmt.Println("Glif Graph - Lotus")
// handle any missing args
switch {
case flag_address == "":
fmt.Fprintln(os.Stderr, "Missing address - please provide the address for the record you'd like to create")
return
case flag_method == 0:
fmt.Fprintln(os.Stderr, "Missing method - please provide the method that you would like to create")
return
}
config, err := util.LoadConfig(".")
if err != nil {
log.Fatal("cannot load config:", err)
}
authToken := "<value found in ~/.lotus/token>"
headers := http.Header{"Authorization": []string{"Bearer " + authToken}}
var api lotusapi.FullNodeStruct
closer, err := jsonrpc.NewMergeClient(context.Background(), config.LotusAddress+"/rpc/v0", "Filecoin", []interface{}{&api.Internal, &api.CommonStruct.Internal}, headers)
if err != nil {
log.Fatalf("connecting with lotus failed: %s", err)
}
defer closer()
addr, err := address.NewFromString(flag_address)
fmt.Println("address: ", addr)
// Now you can call any API you're interested in.
tipset, err := api.ChainHead(context.Background())
actor, err := api.StateGetActor(context.Background(), addr, tipset.Key() )
if err != nil {
log.Fatalf("calling chain head: %s", err)
}
fmt.Println("Current actor cid: ", actor.Code)
fmt.Println("Current actor bal: ", actor.Balance)
// test, err := cid.Decode("bafkqadlgnfwc6nzpmfrwg33vnz2a")
// bafkqadlgnfwc6nrpmfrwg33vnz2a
//bafkqadlgnfwc6nzpmfrwg33vnz2a
//bafkqadlgnfwc6nrpmfrwg33vnz2a
m := make(map[string]interface{})
n := make(map[abi.MethodNum]string)
elem := reflect.ValueOf(&builtin1.MethodsMultisig).Elem()
relType := elem.Type()
for i := 0; i < relType.NumField(); i++ {
m[relType.Field(i).Name] = elem.Field(i).Interface().(abi.MethodNum)
n[elem.Field(i).Interface().(abi.MethodNum)] = relType.Field(i).Name
}
// fmt.Println(m)
// fmt.Println(n)
// test := structs.Map(builtin1.MethodsMultisig)
// fmt.Println("constructor: ",test)
switch(strings.Split(builtin.ActorNameByCode(actor.Code), "/")[2]){
case "account":
fmt.Println("Method: ", n[abi.MethodNum(flag_method)]);
break;
}
fmt.Println("Current actor name: ", strings.Split(builtin.ActorNameByCode(actor.Code), "/")[2])
},
}
func findByValue(m map[string]string, value string) string {
for key, val := range m {
if val == value {
return key
}
}
return ""
}
// Address + Method => MethodName