mirror of
https://github.com/0glabs/0g-chain.git
synced 2024-12-27 00:35:18 +00:00
266 lines
7.8 KiB
Go
266 lines
7.8 KiB
Go
package paychan
|
|
|
|
import (
|
|
sdk "github.com/cosmos/cosmos-sdk/types"
|
|
"github.com/stretchr/testify/assert"
|
|
//"github.com/stretchr/testify/require"
|
|
"github.com/tendermint/tendermint/crypto"
|
|
"testing"
|
|
)
|
|
|
|
func TestKeeper(t *testing.T) {
|
|
|
|
t.Run("CreateChannel", func(t *testing.T) {
|
|
|
|
//
|
|
////// SETUP
|
|
// create basic mock app
|
|
ctx, coinKeeper, channelKeeper, addrs, genAccFunding := createMockApp()
|
|
|
|
sender := addrs[0]
|
|
receiver := addrs[1]
|
|
coins := sdk.Coins{sdk.NewCoin("KVA", 10)}
|
|
|
|
//
|
|
////// ACTION
|
|
_, err := channelKeeper.CreateChannel(ctx, sender, receiver, coins)
|
|
|
|
//
|
|
////// CHECK RESULTS
|
|
assert.Nil(t, err)
|
|
// channel exists with correct attributes
|
|
channelID := ChannelID(0) // should be 0 as first channel
|
|
expectedChan := Channel{
|
|
ID: channelID,
|
|
Participants: [2]sdk.AccAddress{sender, receiver},
|
|
Coins: coins,
|
|
}
|
|
createdChan, _ := channelKeeper.getChannel(ctx, channelID)
|
|
assert.Equal(t, expectedChan, createdChan)
|
|
// check coins deducted from sender
|
|
assert.Equal(t, genAccFunding.Minus(coins), coinKeeper.GetCoins(ctx, sender))
|
|
// check no coins deducted from receiver
|
|
assert.Equal(t, genAccFunding, coinKeeper.GetCoins(ctx, receiver))
|
|
// check next chan id
|
|
assert.Equal(t, ChannelID(1), channelKeeper.getNewChannelID(ctx))
|
|
})
|
|
|
|
t.Run("ReceiverCloseChannel", func(t *testing.T) {
|
|
// SETUP
|
|
ctx, coinKeeper, channelKeeper, addrs, genAccFunding := createMockApp()
|
|
|
|
sender := addrs[0]
|
|
receiver := addrs[1]
|
|
coins := sdk.Coins{sdk.NewCoin("KVA", 10)}
|
|
|
|
// create new channel
|
|
channelID := ChannelID(0) // should be 0 as first channel
|
|
channel := Channel{
|
|
ID: channelID,
|
|
Participants: [2]sdk.AccAddress{sender, receiver},
|
|
Coins: coins,
|
|
}
|
|
channelKeeper.setChannel(ctx, channel)
|
|
|
|
// create closing update
|
|
payouts := Payouts{
|
|
{sender, sdk.Coins{sdk.NewCoin("KVA", 3)}},
|
|
{receiver, sdk.Coins{sdk.NewCoin("KVA", 7)}},
|
|
}
|
|
update := Update{
|
|
ChannelID: channelID,
|
|
Payouts: payouts,
|
|
Sequence: 0,
|
|
Sigs: [1]crypto.Signature{},
|
|
}
|
|
// Set empty submittedUpdatesQueue TODO work out proper genesis initialisation
|
|
channelKeeper.setSubmittedUpdatesQueue(ctx, SubmittedUpdatesQueue{})
|
|
|
|
// ACTION
|
|
_, err := channelKeeper.CloseChannelByReceiver(ctx, update)
|
|
|
|
// CHECK RESULTS
|
|
// no error
|
|
assert.Nil(t, err)
|
|
// coins paid out
|
|
senderPayout, _ := payouts.Get(sender)
|
|
assert.Equal(t, genAccFunding.Plus(senderPayout), coinKeeper.GetCoins(ctx, sender))
|
|
receiverPayout, _ := payouts.Get(receiver)
|
|
assert.Equal(t, genAccFunding.Plus(receiverPayout), coinKeeper.GetCoins(ctx, receiver))
|
|
// channel deleted
|
|
_, found := channelKeeper.getChannel(ctx, channelID)
|
|
assert.False(t, found)
|
|
|
|
})
|
|
|
|
t.Run("SenderInitCloseChannel", func(t *testing.T) {
|
|
// SETUP
|
|
ctx, _, channelKeeper, addrs, _ := createMockApp()
|
|
|
|
sender := addrs[0]
|
|
receiver := addrs[1]
|
|
coins := sdk.Coins{sdk.NewCoin("KVA", 10)}
|
|
|
|
// create new channel
|
|
channelID := ChannelID(0) // should be 0 as first channel
|
|
channel := Channel{
|
|
ID: channelID,
|
|
Participants: [2]sdk.AccAddress{sender, receiver},
|
|
Coins: coins,
|
|
}
|
|
channelKeeper.setChannel(ctx, channel)
|
|
|
|
// create closing update
|
|
payouts := Payouts{
|
|
{sender, sdk.Coins{sdk.NewCoin("KVA", 3)}},
|
|
{receiver, sdk.Coins{sdk.NewCoin("KVA", 7)}},
|
|
}
|
|
update := Update{
|
|
ChannelID: channelID,
|
|
Payouts: payouts,
|
|
Sequence: 0,
|
|
Sigs: [1]crypto.Signature{},
|
|
}
|
|
// Set empty submittedUpdatesQueue TODO work out proper genesis initialisation
|
|
channelKeeper.setSubmittedUpdatesQueue(ctx, SubmittedUpdatesQueue{})
|
|
|
|
// ACTION
|
|
_, err := channelKeeper.InitCloseChannelBySender(ctx, update)
|
|
|
|
// CHECK RESULTS
|
|
// no error
|
|
assert.Nil(t, err)
|
|
// submittedupdate in queue and correct
|
|
suq, found := channelKeeper.getSubmittedUpdatesQueue(ctx)
|
|
assert.True(t, found)
|
|
assert.True(t, suq.Contains(channelID))
|
|
|
|
su, found := channelKeeper.getSubmittedUpdate(ctx, channelID)
|
|
assert.True(t, found)
|
|
expectedSubmittedUpdate := SubmittedUpdate{
|
|
Update: update,
|
|
ExecutionTime: ChannelDisputeTime,
|
|
}
|
|
assert.Equal(t, expectedSubmittedUpdate, su)
|
|
// TODO check channel is still in db and coins haven't changed?
|
|
})
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
func setupMultiStore() (sdk.MultiStore, *sdk.KVStoreKey, *sdk.KVStoreKey) {
|
|
// create db
|
|
db := dbm.NewMemDB()
|
|
// create keys
|
|
authKey := sdk.NewKVStoreKey("authkey")
|
|
paychanKey := sdk.NewKVStoreKey("paychankey")
|
|
// create new multistore around db
|
|
ms := store.NewCommitMultiStore(db) // DB handle plus store key maps
|
|
// register separate stores in the multistore
|
|
ms.MountStoreWithDB(authKey, sdk.StoreTypeIAVL, db) // sets store key map
|
|
ms.MountStoreWithDB(paychanKey, sdk.StoreTypeIAVL, db)
|
|
ms.LoadLatestVersion()
|
|
|
|
return ms, authKey, paychanKey
|
|
}
|
|
|
|
func setupCodec() *wire.Codec {
|
|
cdc := wire.NewCodec()
|
|
auth.RegisterBaseAccount(cdc)
|
|
// TODO might need to register paychan struct
|
|
return cdc
|
|
}
|
|
|
|
func TestKeeper(t *testing.T) {
|
|
// Setup
|
|
|
|
// create multistore and key
|
|
ms, authKey, paychanKey := setupMultiStore()
|
|
|
|
// create and initialise codec(s)
|
|
cdc := setupCodec()
|
|
|
|
// create context
|
|
ctx := sdk.NewContext(ms, abci.Header{}, false, nil, log.NewNopLogger())
|
|
|
|
// create accountMapper
|
|
accountMapper := auth.NewAccountMapper(cdc, authKey, &auth.BaseAccount{})
|
|
|
|
// create coinkeeper
|
|
coinKeeper := bank.NewKeeper(accountMapper)
|
|
|
|
// create keeper
|
|
paychanKeeper := NewKeeper(cdc, paychanKey, coinKeeper)
|
|
|
|
// Test no paychans exist
|
|
_, exists := paychanKeeper.GetPaychan(ctx, sdk.Address{}, sdk.Address{}, 0)
|
|
if exists {
|
|
t.Error("payment channel found when none exist")
|
|
}
|
|
|
|
// Test paychan can be set and get
|
|
p := Paychan{
|
|
Sender: sdk.Address([]byte("senderAddress")),
|
|
Receiver: sdk.Address([]byte("receiverAddress")),
|
|
Id: 0,
|
|
Balance: sdk.Coins{{"KVA", 100}},
|
|
}
|
|
paychanKeeper.setPaychan(ctx, p)
|
|
|
|
_, exists = paychanKeeper.GetPaychan(ctx, p.Sender, p.Receiver, p.Id)
|
|
if !exists {
|
|
t.Error("payment channel not found")
|
|
}
|
|
|
|
// Test create paychan under normal conditions
|
|
senderAddress := sdk.Address([]byte("senderAddress"))
|
|
senderFunds := sdk.Coins{{"KVA", 100}}
|
|
receiverAddress := sdk.Address([]byte("receiverAddress"))
|
|
balance := sdk.Coins{{"KVA", 10}}
|
|
|
|
coinKeeper.SetCoins(ctx, senderAddress, senderFunds)
|
|
|
|
_, err := paychanKeeper.CreatePaychan(ctx, senderAddress, receiverAddress, balance)
|
|
if err != nil {
|
|
t.Error("unexpected error created payment channel", err)
|
|
}
|
|
|
|
p, exists = paychanKeeper.GetPaychan(ctx, senderAddress, receiverAddress, 0)
|
|
if !exists {
|
|
t.Error("payment channel missing")
|
|
}
|
|
if !p.Balance.IsEqual(balance) {
|
|
t.Error("payment channel balance incorrect", p.Balance, balance)
|
|
}
|
|
expectedNewSenderFunds := senderFunds.Minus(balance)
|
|
if !coinKeeper.GetCoins(ctx, senderAddress).IsEqual(expectedNewSenderFunds) {
|
|
t.Error("sender has incorrect balance after paychan creation")
|
|
}
|
|
|
|
// Test close paychan under normal conditions
|
|
senderFunds = coinKeeper.GetCoins(ctx, senderAddress)
|
|
receiverAmount := sdk.Coins{{"KVA", 9}}
|
|
_, err = paychanKeeper.ClosePaychan(ctx, senderAddress, receiverAddress, 0, receiverAmount)
|
|
if err != nil {
|
|
t.Error("unexpected error closing payment channel", err)
|
|
}
|
|
// paychan shouldn't exist
|
|
_, exists = paychanKeeper.GetPaychan(ctx, senderAddress, receiverAddress, 0)
|
|
if exists {
|
|
t.Error("payment channel should not exist")
|
|
}
|
|
// sender's funds should have increased
|
|
expectedNewSenderFunds = senderFunds.Plus(balance.Minus(receiverAmount))
|
|
if !coinKeeper.GetCoins(ctx, senderAddress).IsEqual(expectedNewSenderFunds) {
|
|
t.Error("sender has incorrect balance after paychan creation", expectedNewSenderFunds)
|
|
}
|
|
// receiver's funds should have increased
|
|
expectedNewReceiverFunds := receiverAmount // started at zero
|
|
if !coinKeeper.GetCoins(ctx, receiverAddress).IsEqual(expectedNewReceiverFunds) {
|
|
t.Error("receiver has incorrect balance after paychan creation")
|
|
}
|
|
|
|
}
|
|
*/
|