forked from coming-chat/wallet-SDK
-
Notifications
You must be signed in to change notification settings - Fork 0
/
chain.go
127 lines (107 loc) · 3.18 KB
/
chain.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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
package doge
import (
"encoding/json"
"sort"
"strconv"
"strings"
"github.com/coming-chat/wallet-SDK/core/base"
)
type Chain struct {
*Util
}
func NewChainWithChainnet(chainnet string) (*Chain, error) {
util, err := NewUtilWithChainnet(chainnet)
if err != nil {
return nil, err
}
return &Chain{Util: util}, nil
}
// MARK - Implement the protocol Chain
func (c *Chain) MainToken() base.Token {
return c
}
func (c *Chain) BalanceOfAddress(address string) (*base.Balance, error) {
return queryBalance(address, c.Chainnet)
}
func (c *Chain) BalanceOfPublicKey(publicKey string) (*base.Balance, error) {
address, err := EncodePublicKeyToAddress(publicKey, c.Chainnet)
if err != nil {
return nil, err
}
return c.BalanceOfAddress(address)
}
func (c *Chain) BalanceOfAccount(account base.Account) (*base.Balance, error) {
return c.BalanceOfAddress(account.Address())
}
// Send the raw transaction on-chain
// @return the hex hash string
func (c *Chain) SendRawTransaction(signedTx string) (string, error) {
transaction, err := sendRawTransaction(signedTx, c.Chainnet)
if err != nil {
return "", err
}
return transaction.Hash, nil
}
// Fetch transaction details through transaction hash
func (c *Chain) FetchTransactionDetail(hash string) (*base.TransactionDetail, error) {
d, err := fetchTransactionDetail(hash, c.Chainnet)
if err != nil {
return nil, err
} else {
return d.SdkDetail(), nil
}
}
func (c *Chain) FetchTransactionStatus(hash string) base.TransactionStatus {
d, err := fetchTransactionDetail(hash, c.Chainnet)
if err != nil {
return base.TransactionStatusNone
} else {
return d.Status()
}
}
func (c *Chain) BatchFetchTransactionStatus(hashListString string) string {
hashList := strings.Split(hashListString, ",")
statuses, _ := base.MapListConcurrentStringToString(hashList, func(s string) (string, error) {
return strconv.Itoa(c.FetchTransactionStatus(s)), nil
})
return strings.Join(statuses, ",")
}
func (c *Chain) EstimateTransactionFee(transaction base.Transaction) (fee *base.OptionalString, err error) {
return nil, base.ErrUnsupportedFunction
}
func (c *Chain) EstimateTransactionFeeUsePublicKey(transaction base.Transaction, pubkey string) (fee *base.OptionalString, err error) {
return c.EstimateTransactionFee(transaction)
}
// @param limit Specify how many the latest utxos to fetch, The minimum value of the limit is 100.
func (c *Chain) FetchUtxos(address string, limit int) (*base.OptionalString, error) {
limit = base.Max(100, limit)
res, err := fetchUtxos(address, c.Chainnet, limit)
if err != nil {
return nil, err
}
utxos := res.Utxos
sort.Slice(utxos, func(i, j int) bool {
return utxos[i].Value.Cmp(utxos[j].Value) == 1
})
feeRate, err := c.SuggestFeeRate()
if err != nil {
return nil, err
}
sdklist := &SDKUTXOList{
Txids: utxos,
FastestFee: int(feeRate.Average),
}
data, err := json.Marshal(sdklist)
if err != nil {
return nil, err
}
return &base.OptionalString{Value: string(data)}, nil
}
type FeeRate struct {
Low int64 `json:"low_fee_per_kb"`
Average int64 `json:"medium_fee_per_kb"`
High int64 `json:"high_fee_per_kb"`
}
func (c *Chain) SuggestFeeRate() (*FeeRate, error) {
return suggestFeeRate(c.Chainnet)
}