solana-go-sdk/client/rpc_get_account_info.go at 6f4d3da1b45a0474ea451fc47c2533d03f8a23a9 · blocto/solana-go-sdk · GitHub

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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
package client

import (
	"context"
	"encoding/base64"
	"encoding/json"
	"fmt"

	"github.com/portto/solana-go-sdk/common"
	"github.com/portto/solana-go-sdk/rpc"
)

type AccountInfo struct {
	Lamports   uint64
	Owner      common.PublicKey
	Executable bool
	RentEpoch  uint64
	Data       []byte
}

func convertAccountInfo(v rpc.AccountInfo) (AccountInfo, error) {
	if v == (rpc.AccountInfo{}) {
		return AccountInfo{}, nil
	}
	data, ok := v.Data.([]any)
	if !ok {
		return AccountInfo{}, fmt.Errorf("failed to cast raw response to []any")
	}
	if data[1] != string(rpc.AccountEncodingBase64) {
		return AccountInfo{}, fmt.Errorf("return value should be base64 encoded")
	}
	rawData, err := base64.StdEncoding.DecodeString(data[0].(string))
	if err != nil {
		return AccountInfo{}, fmt.Errorf("failed to base64 decode data")
	}
	return AccountInfo{
		Lamports:   v.Lamports,
		Owner:      common.PublicKeyFromString(v.Owner),
		Executable: v.Executable,
		RentEpoch:  v.RentEpoch,
		Data:       rawData,
	}, nil
}

func convertAccountInfoWithData(v rpc.AccountInfoWithData) (AccountInfo, error) {
	if v == (rpc.AccountInfoWithData{}) {
		return AccountInfo{}, nil
	}
	rawData, err := json.Marshal(v.Data)
	if err != nil {
		return AccountInfo{}, fmt.Errorf("failed to base64 decode data")
	}
	return AccountInfo{
		Lamports:   v.Lamports,
		Owner:      common.PublicKeyFromString(v.Owner),
		Executable: v.Executable,
		RentEpoch:  v.RentEpoch,
		Data:       rawData,
	}, nil
}

type GetAccountInfoConfig struct {
	Encoding   rpc.AccountEncoding
	Commitment rpc.Commitment
	DataSlice  *rpc.DataSlice
}

func (c GetAccountInfoConfig) toRpc() rpc.GetAccountInfoConfig {
	if c.Encoding == "" {
		c.Encoding = rpc.AccountEncodingBase64
	}
	return rpc.GetAccountInfoConfig{
		Encoding:   c.Encoding,
		Commitment: c.Commitment,
		DataSlice:  c.DataSlice,
	}
}

// GetAccountInfo return account's info
func (c *Client) GetAccountInfo(ctx context.Context, base58Addr string) (AccountInfo, error) {
	return process(
		func() (rpc.JsonRpcResponse[rpc.ValueWithContext[rpc.AccountInfo]], error) {
			return c.RpcClient.GetAccountInfoWithConfig(ctx, base58Addr, GetAccountInfoConfig{}.toRpc())
		},
		convertGetAccountInfo,
	)
}

// GetAccountInfoWithConfig return account's info
func (c *Client) GetAccountInfoWithConfig(ctx context.Context, base58Addr string, cfg GetAccountInfoConfig) (AccountInfo, error) {
	if cfg.Encoding == rpc.AccountEncodingJsonParsed {
		return process(
			func() (rpc.JsonRpcResponse[rpc.ValueWithContext[rpc.AccountInfo]], error) {
				return c.RpcClient.GetAccountInfoWithConfig(ctx, base58Addr, cfg.toRpc())
			},
			convertGetAccountInfoWithData,
		)
	}
	return process(
		func() (rpc.JsonRpcResponse[rpc.ValueWithContext[rpc.AccountInfo]], error) {
			return c.RpcClient.GetAccountInfoWithConfig(ctx, base58Addr, cfg.toRpc())
		},
		convertGetAccountInfo,
	)
}

// GetAccountInfoAndContext return account's info
func (c *Client) GetAccountInfoAndContext(ctx context.Context, base58Addr string) (rpc.ValueWithContext[AccountInfo], error) {
	return process(
		func() (rpc.JsonRpcResponse[rpc.ValueWithContext[rpc.AccountInfo]], error) {
			return c.RpcClient.GetAccountInfoWithConfig(ctx, base58Addr, GetAccountInfoConfig{Encoding: rpc.AccountEncodingBase64}.toRpc())
		},
		convertGetAccountInfoAndContext,
	)
}

// GetAccountInfoAndContextWithConfig return account's info
func (c *Client) GetAccountInfoAndContextWithConfig(ctx context.Context, base58Addr string, cfg GetAccountInfoConfig) (rpc.ValueWithContext[AccountInfo], error) {
	return process(
		func() (rpc.JsonRpcResponse[rpc.ValueWithContext[rpc.AccountInfo]], error) {
			return c.RpcClient.GetAccountInfoWithConfig(ctx, base58Addr, cfg.toRpc())
		},
		convertGetAccountInfoAndContext,
	)
}

func convertGetAccountInfo(v rpc.ValueWithContext[rpc.AccountInfo]) (AccountInfo, error) {
	return convertAccountInfo(v.Value)
}

func convertGetAccountInfoWithData(v rpc.ValueWithContext[rpc.AccountInfoWithData]) (AccountInfo, error) {
	return convertAccountInfoWithData(v.Value)
}

func convertGetAccountInfoAndContext(v rpc.ValueWithContext[rpc.AccountInfo]) (rpc.ValueWithContext[AccountInfo], error) {
	accountInfo, err := convertGetAccountInfo(v)
	if err != nil {
		return rpc.ValueWithContext[AccountInfo]{}, err
	}
	return rpc.ValueWithContext[AccountInfo]{
		Context: v.Context,
		Value:   accountInfo,
	}, nil
}