Skip to content

Commit bafafc3

Browse files
b00fb00f
committed
fix: make store in memory and file persistence
1 parent 4cbbebe commit bafafc3

File tree

11 files changed

+197
-257
lines changed

11 files changed

+197
-257
lines changed

‎client/client_mgr.go

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -91,7 +91,7 @@ func (cm *Mgr) GetPeerInfoFirstVal(address string) (*pactus.PeerInfo, error) {
9191

9292
if networkInfo != nil {
9393
for _, p := range networkInfo.ConnectedPeers {
94-
for i, addr := range p.ConsensusKeys {
94+
for i, addr := range p.ConsensusAddress {
9595
if addr == address {
9696
if i != 0 {
9797
return nil, errors.New("please enter the first validator address")

‎engine/engine.go

Lines changed: 32 additions & 40 deletions
Original file line numberDiff line numberDiff line change
@@ -14,7 +14,6 @@ import (
1414
"github.com/kehiy/RoboPac/utils"
1515
"github.com/kehiy/RoboPac/wallet"
1616
"github.com/libp2p/go-libp2p/core/peer"
17-
"github.com/pactus-project/pactus/util"
1817
)
1918

2019
const (
@@ -30,11 +29,11 @@ type BotEngine struct {
3029
sync.RWMutex
3130
}
3231

33-
func NewBotEngine(config *config.Config) (IEngine, error) {
32+
func NewBotEngine(cfg *config.Config) (IEngine, error) {
3433
cm := client.NewClientMgr()
35-
c, err := client.NewClient(config.LocalNode)
34+
c, err := client.NewClient(cfg.LocalNode)
3635
if err != nil {
37-
log.Error("can't make a new local-net client", "err", err, "addr", config.LocalNode)
36+
log.Error("can't make a new local-net client", "err", err, "addr", cfg.LocalNode)
3837
return nil, err
3938
}
4039

@@ -53,20 +52,20 @@ func NewBotEngine(config *config.Config) (IEngine, error) {
5352
wSl := log.NewSubLogger("wallet")
5453

5554
// load or create wallet.
56-
wallet := wallet.Open(config, wSl)
55+
wallet := wallet.Open(cfg, wSl)
5756
if wallet == nil {
58-
log.Panic("wallet could not be opened, wallet is nil", "path", config.WalletPath)
57+
log.Panic("wallet could not be opened, wallet is nil", "path", cfg.WalletPath)
5958
}
6059

6160
log.Info("wallet opened successfully", "address", wallet.Address())
6261

6362
// load store.
64-
store, err := store.LoadStore(config, sSl)
63+
store, err := store.NewStore(cfg, sSl)
6564
if err != nil {
66-
log.Panic("could not load store", "err", err, "path", config.StorePath)
65+
log.Panic("could not load store", "err", err, "path", cfg.StorePath)
6766
}
6867

69-
log.Info("store loaded successfully", "path", config.StorePath)
68+
log.Info("store loaded successfully", "path", cfg.StorePath)
7069

7170
return newBotEngine(eSl, cm, wallet, store), nil
7271
}
@@ -217,62 +216,55 @@ func (be *BotEngine) ClaimerInfo(tokens []string) (*store.Claimer, error) {
217216
return claimer, nil
218217
}
219218

220-
func (be *BotEngine) Claim(discordID string, testNetValAddr string, valAddr string) (*store.ClaimTransaction, error) {
219+
func (be *BotEngine) Claim(discordID string, testnetAddr string, mainnetAddr string) (string, error) {
221220
be.Lock()
222221
defer be.Unlock()
223222

224-
be.logger.Info("new claim request", "valAddr", valAddr, "testNetValAddr", testNetValAddr, "discordID", discordID)
223+
be.logger.Info("new claim request", "mainnetAddr", mainnetAddr, "testnetAddr", testnetAddr, "discordID", discordID)
225224

226-
claimer := be.Store.ClaimerInfo(testNetValAddr)
225+
claimer := be.Store.ClaimerInfo(testnetAddr)
227226
if claimer == nil {
228-
return nil, errors.New("claimer not found")
227+
return "", errors.New("claimer not found")
229228
}
230229

231230
if claimer.IsClaimed() {
232-
return nil, errors.New("this claimer have already claimed rewards")
231+
return "", errors.New("this claimer have already claimed rewards")
233232
}
234233

235-
isValidator, err := be.Cm.IsValidator(valAddr)
234+
isValidator, err := be.Cm.IsValidator(mainnetAddr)
236235
if err != nil {
237-
return nil, err
236+
return "", err
238237
}
239-
240238
if !isValidator {
241-
return nil, errors.New("invalid argument: validator address")
239+
return "", errors.New("invalid argument: validator address")
242240
}
243241

244-
memo := fmt.Sprintf("RP to: %v", discordID)
245-
246-
txID, err := be.Wallet.BondTransaction("", valAddr, memo, claimer.TotalReward)
242+
peerInfo, err := be.Cm.GetPeerInfoFirstVal(mainnetAddr)
247243
if err != nil {
248-
return nil, err
249-
}
250-
251-
be.logger.Info("new bond transaction sent", "txID", txID, "memo", memo)
252-
253-
if txID == "" {
254-
return nil, errors.New("can't send bond transaction")
244+
return "", err
255245
}
256246

257-
txData, err := be.Cm.GetTransactionData(txID)
247+
txID, err := be.Wallet.BondTransaction(peerInfo.ConsensusKeys[0], mainnetAddr, "", claimer.TotalReward)
258248
if err != nil {
259-
return nil, err
249+
return "", err
250+
}
251+
if txID == "" {
252+
return "", errors.New("can't send bond transaction")
260253
}
254+
be.logger.Info("new bond transaction sent", "txID", txID)
261255

262-
err = be.Store.AddClaimTransaction(util.ChangeToCoin(txData.Transaction.Value),
263-
int64(txData.BlockTime), txID, discordID, testNetValAddr)
256+
err = be.Store.AddClaimTransaction(testnetAddr, txID)
264257
if err != nil {
265-
return nil, err
266-
}
258+
be.logger.Panic("unable to add the claim transaction",
259+
"error", err,
260+
"discordID", discordID,
261+
"testnetAddr", testnetAddr,
262+
"txID", txID)
267263

268-
claimer = be.Store.ClaimerInfo(testNetValAddr)
269-
if claimer == nil {
270-
return nil, errors.New("can't save claim info")
264+
return "", err
271265
}
272266

273-
be.logger.Info("new claimer added", "valAddr", valAddr, "discordID", discordID)
274-
275-
return claimer.ClaimTransaction, nil
267+
return txID, nil
276268
}
277269

278270
func (be *BotEngine) Stop() {

‎engine/engine_test.go

Lines changed: 98 additions & 110 deletions
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,6 @@
11
package engine
22

33
import (
4-
"fmt"
54
"testing"
65
"time"
76

@@ -10,7 +9,6 @@ import (
109
rpstore "github.com/kehiy/RoboPac/store"
1110
"github.com/kehiy/RoboPac/wallet"
1211
"github.com/libp2p/go-libp2p/core/peer"
13-
"github.com/pactus-project/pactus/util"
1412
pactus "github.com/pactus-project/pactus/www/grpc/gen/go"
1513
"github.com/stretchr/testify/assert"
1614
"go.uber.org/mock/gomock"
@@ -150,138 +148,128 @@ func TestClaim(t *testing.T) {
150148
eng, client, store, wallet := setup(t)
151149

152150
t.Run("everything normal and good", func(t *testing.T) {
153-
valAddress := "pc1p74scge5dyzjktv9q70xtr0pjmyqcqk7nuh8nzp"
154-
testNetValAddr := "tpc1pqn7uaeduklpg00rqt6uq0m9wy5txnyt0kmxmgf"
151+
mainnetAddr := "mainnet-addr"
152+
testnetAddr := "testnet-addr"
155153
discordID := "123456789"
156-
txID := "0x123456789"
157-
amount := float64(74)
158-
time := time.Now().Unix()
154+
amount := int64(74)
155+
txID := "tx-id"
159156

160-
client.EXPECT().IsValidator(valAddress).Return(
157+
client.EXPECT().IsValidator(mainnetAddr).Return(
161158
true, nil,
162-
)
159+
).AnyTimes()
163160

164-
store.EXPECT().ClaimerInfo(testNetValAddr).Return(
161+
store.EXPECT().ClaimerInfo(testnetAddr).Return(
165162
&rpstore.Claimer{
166-
DiscordID: discordID,
167-
TotalReward: amount,
168-
ClaimTransaction: nil,
163+
DiscordID: discordID,
164+
TotalReward: amount,
165+
ClaimedTxID: "",
169166
},
170167
)
171168

172-
memo := fmt.Sprintf("RP to: %v", discordID)
173-
wallet.EXPECT().BondTransaction("", valAddress, memo, amount).Return(
174-
txID, nil,
175-
)
176-
177-
client.EXPECT().GetTransactionData(txID).Return(
178-
&pactus.GetTransactionResponse{
179-
BlockTime: uint32(time),
180-
Transaction: &pactus.TransactionInfo{
181-
Id: []byte(txID),
182-
Value: util.CoinToChange(amount),
183-
Memo: memo,
169+
client.EXPECT().GetNetworkInfo().Return(
170+
&pactus.GetNetworkInfoResponse{
171+
ConnectedPeers: []*pactus.PeerInfo{
172+
{
173+
ConsensusAddress: []string{mainnetAddr},
174+
ConsensusKeys: []string{"public-key-1"},
175+
},
184176
},
185177
}, nil,
178+
).AnyTimes()
179+
180+
wallet.EXPECT().BondTransaction("public-key-1", mainnetAddr, "", amount).Return(
181+
txID, nil,
186182
)
187183

188-
store.EXPECT().AddClaimTransaction(amount, time, txID, discordID, testNetValAddr).Return(
184+
store.EXPECT().AddClaimTransaction(testnetAddr, txID).Return(
189185
nil,
190186
)
191187

192-
store.EXPECT().ClaimerInfo(testNetValAddr).Return(
193-
&rpstore.Claimer{
194-
DiscordID: discordID,
195-
TotalReward: amount,
196-
ClaimTransaction: &rpstore.ClaimTransaction{
197-
TxID: txID,
198-
Amount: amount,
199-
Time: time,
200-
},
201-
},
202-
).AnyTimes()
203-
204-
claimTx, err := eng.Claim([]string{valAddress, testNetValAddr, discordID})
188+
expectedTx, err := eng.Claim(discordID, testnetAddr, mainnetAddr)
205189
assert.NoError(t, err)
206-
assert.NotNil(t, claimTx)
207-
208-
assert.Equal(t, amount, claimTx.Amount)
209-
assert.Equal(t, txID, claimTx.TxID)
210-
assert.Equal(t, time, claimTx.Time)
190+
assert.NotNil(t, expectedTx, txID)
211191

212192
//! can't claim twice.
213-
claimTx, err = eng.Claim([]string{valAddress, testNetValAddr, discordID})
214-
assert.EqualError(t, err, "this claimer have already claimed rewards")
215-
assert.Nil(t, claimTx)
216-
})
217-
218-
t.Run("missing arguments", func(t *testing.T) {
219-
claimTx, err := eng.Claim()
220-
assert.EqualError(t, err, "missing argument: validator address")
221-
assert.Nil(t, claimTx)
222-
})
223-
224-
t.Run("claimer not found", func(t *testing.T) {
225-
valAddress := "pc1p74scge5dyzjktv9q70xtr0pjmyqcqk7nuh8nzp"
226-
testNetValAddr := "tpc1peaeyzmwjqu6nz93c27hr8ad2l265tx4s9v6zhw"
227-
discordID := "987654321"
228193

229-
store.EXPECT().ClaimerInfo(testNetValAddr).Return(
230-
nil,
231-
)
232-
233-
claimTx, err := eng.Claim([]string{valAddress, testNetValAddr, discordID})
234-
assert.EqualError(t, err, "claimer not found")
235-
assert.Nil(t, claimTx)
236-
})
237-
238-
t.Run("not validator address", func(t *testing.T) {
239-
valAddress := "pc1p74scge5dyzjktv9q70xtr0pjmyqcqk7nuh8nzp"
240-
testNetValAddr := "tpc1p2vx5t8sglhvncmp3en0qhgtxyc59w0gfgnaqe7"
241-
discordID := "1234567890"
242-
amount := 74.68
243-
244-
store.EXPECT().ClaimerInfo(testNetValAddr).Return(
194+
store.EXPECT().ClaimerInfo(testnetAddr).Return(
245195
&rpstore.Claimer{
246196
DiscordID: discordID,
247197
TotalReward: amount,
198+
ClaimedTxID: txID,
248199
},
249200
)
250-
251-
client.EXPECT().IsValidator(valAddress).Return(
252-
false, nil,
253-
)
254-
255-
claimTx, err := eng.Claim([]string{valAddress, testNetValAddr, discordID})
256-
assert.EqualError(t, err, "invalid argument: validator address")
257-
assert.Nil(t, claimTx)
201+
expectedTx, err = eng.Claim(discordID, testnetAddr, mainnetAddr)
202+
assert.Error(t, err)
203+
assert.Empty(t, expectedTx)
258204
})
259205

260-
t.Run("empty transaction ID", func(t *testing.T) {
261-
valAddress := "pc1p74scge5dyzjktv9q70xtr0pjmyqcqk7nuh8nzp"
262-
testNetValAddr := "tpc1pvmundkkp83u5cfz04sem5r7688dc0lef5u0mmv"
263-
discordID := "1234567890"
264-
amount := 74.68
265-
266-
client.EXPECT().IsValidator(valAddress).Return(
267-
true, nil,
268-
)
269-
270-
store.EXPECT().ClaimerInfo(testNetValAddr).Return(
271-
&rpstore.Claimer{
272-
DiscordID: discordID,
273-
TotalReward: amount,
274-
ClaimTransaction: nil,
275-
},
276-
)
277-
278-
memo := fmt.Sprintf("RP to: %v", discordID)
279-
wallet.EXPECT().BondTransaction("", valAddress, memo, amount).Return(
280-
"", nil,
281-
)
282-
283-
claimTx, err := eng.Claim([]string{valAddress, testNetValAddr, discordID})
284-
assert.EqualError(t, err, "can't send bond transaction")
285-
assert.Nil(t, claimTx)
286-
})
206+
// t.Run("missing arguments", func(t *testing.T) {
207+
// claimTx, err := eng.Claim()
208+
// assert.EqualError(t, err, "missing argument: validator address")
209+
// assert.Nil(t, claimTx)
210+
// })
211+
212+
// t.Run("claimer not found", func(t *testing.T) {
213+
// valAddress := "pc1p74scge5dyzjktv9q70xtr0pjmyqcqk7nuh8nzp"
214+
// testNetValAddr := "tpc1peaeyzmwjqu6nz93c27hr8ad2l265tx4s9v6zhw"
215+
// discordID := "987654321"
216+
217+
// store.EXPECT().ClaimerInfo(testNetValAddr).Return(
218+
// nil,
219+
// )
220+
221+
// claimTx, err := eng.Claim([]string{valAddress, testNetValAddr, discordID})
222+
// assert.EqualError(t, err, "claimer not found")
223+
// assert.Nil(t, claimTx)
224+
// })
225+
226+
// t.Run("not validator address", func(t *testing.T) {
227+
// valAddress := "pc1p74scge5dyzjktv9q70xtr0pjmyqcqk7nuh8nzp"
228+
// testNetValAddr := "tpc1p2vx5t8sglhvncmp3en0qhgtxyc59w0gfgnaqe7"
229+
// discordID := "1234567890"
230+
// amount := 74.68
231+
232+
// store.EXPECT().ClaimerInfo(testNetValAddr).Return(
233+
// &rpstore.Claimer{
234+
// DiscordID: discordID,
235+
// TotalReward: amount,
236+
// },
237+
// )
238+
239+
// client.EXPECT().IsValidator(valAddress).Return(
240+
// false, nil,
241+
// )
242+
243+
// claimTx, err := eng.Claim([]string{valAddress, testNetValAddr, discordID})
244+
// assert.EqualError(t, err, "invalid argument: validator address")
245+
// assert.Nil(t, claimTx)
246+
// })
247+
248+
// t.Run("empty transaction ID", func(t *testing.T) {
249+
// valAddress := "pc1p74scge5dyzjktv9q70xtr0pjmyqcqk7nuh8nzp"
250+
// testNetValAddr := "tpc1pvmundkkp83u5cfz04sem5r7688dc0lef5u0mmv"
251+
// discordID := "1234567890"
252+
// amount := 74.68
253+
254+
// client.EXPECT().IsValidator(valAddress).Return(
255+
// true, nil,
256+
// )
257+
258+
// store.EXPECT().ClaimerInfo(testNetValAddr).Return(
259+
// &rpstore.Claimer{
260+
// DiscordID: discordID,
261+
// TotalReward: amount,
262+
// ClaimTransaction: nil,
263+
// },
264+
// )
265+
266+
// memo := fmt.Sprintf("RP to: %v", discordID)
267+
// wallet.EXPECT().BondTransaction("", valAddress, memo, amount).Return(
268+
// "", nil,
269+
// )
270+
271+
// claimTx, err := eng.Claim([]string{valAddress, testNetValAddr, discordID})
272+
// assert.EqualError(t, err, "can't send bond transaction")
273+
// assert.Nil(t, claimTx)
274+
// })
287275
}

0 commit comments

Comments
 (0)