status-im
/
status-go
mirror of https://github.com/status-im/status-go.git
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
status-go/services/wallet/history/balance_test.go

532 lines
11 KiB
Go
Raw Normal View History

feat: retrieve balance history for tokens and cache it to DB Extends wallet module with the history package with the following components: BalanceDB (balance_db.go) - Keeps track of balance information (token count, block, block timestamp) for a token identity (chain, address, currency) - The cached data is stored in `balance_history` table. - Uniqueness constrained is enforced by the `balance_history_identify_entry` UNIQUE index. - Optimal DB fetching is ensured by the `balance_history_filter_entries` index Balance (balance.go) - Provides two stages: - Fetch of balance history using RPC calls (Balance.update function) - Retrieving of cached balance data from the DB it exists (Balance.get function) - Fetching and retrieving of data is done for specific time intervals defined by TimeInterval "enumeration" - Update process is done for a token identity by the Balance.Update function - The granularity of data points returned is defined by the constant increment step define in `timeIntervalToStride` for each time interval. - The `blocksStride` values have a common divisor to have cache hit between time intervals. Service (service.go) - Main APIs - StartBalanceHistory: Regularly updates balance history for all enabled networks, available accounts and provided tokens. - GetBalanceHistory: retrieves cached token count for a token identity (chain, address, currency) for multiple chains - UpdateVisibleTokens: will set the list of tokens to have historical balance fetched. This is a simplification to limit tokens to a small list that make sense Fetch balance history for ECR20 tokens - Add token.Manager.GetTokenBalanceAt to fetch balance of a specific block number of ECR20. - Add tokenChainClientSource concrete implementation of DataSource to fetch balance of ECR20 tokens. - Chose the correct DataSource implementation based on the token "is native" property. Tests Tests are implemented using a mock of `DataSource` interface used to intercept the RPC calls. Notes: - the timestamp used for retrieving block balance is constant Closes status-desktop: #8175, #8226, #8862
2022-11-15 12:14:41 +00:00
package history
import (
"math/big"
Implemented balance history based on transfers (#4022) * feat(wallet): implement balance history based on fetched transfers * Added vendor 'ttlcache'
2023-10-04 12:00:12 +00:00
"reflect"
feat: retrieve balance history for tokens and cache it to DB Extends wallet module with the history package with the following components: BalanceDB (balance_db.go) - Keeps track of balance information (token count, block, block timestamp) for a token identity (chain, address, currency) - The cached data is stored in `balance_history` table. - Uniqueness constrained is enforced by the `balance_history_identify_entry` UNIQUE index. - Optimal DB fetching is ensured by the `balance_history_filter_entries` index Balance (balance.go) - Provides two stages: - Fetch of balance history using RPC calls (Balance.update function) - Retrieving of cached balance data from the DB it exists (Balance.get function) - Fetching and retrieving of data is done for specific time intervals defined by TimeInterval "enumeration" - Update process is done for a token identity by the Balance.Update function - The granularity of data points returned is defined by the constant increment step define in `timeIntervalToStride` for each time interval. - The `blocksStride` values have a common divisor to have cache hit between time intervals. Service (service.go) - Main APIs - StartBalanceHistory: Regularly updates balance history for all enabled networks, available accounts and provided tokens. - GetBalanceHistory: retrieves cached token count for a token identity (chain, address, currency) for multiple chains - UpdateVisibleTokens: will set the list of tokens to have historical balance fetched. This is a simplification to limit tokens to a small list that make sense Fetch balance history for ECR20 tokens - Add token.Manager.GetTokenBalanceAt to fetch balance of a specific block number of ECR20. - Add tokenChainClientSource concrete implementation of DataSource to fetch balance of ECR20 tokens. - Chose the correct DataSource implementation based on the token "is native" property. Tests Tests are implemented using a mock of `DataSource` interface used to intercept the RPC calls. Notes: - the timestamp used for retrieving block balance is constant Closes status-desktop: #8175, #8226, #8862
2022-11-15 12:14:41 +00:00
"testing"
Implemented balance history based on transfers (#4022) * feat(wallet): implement balance history based on fetched transfers * Added vendor 'ttlcache'
2023-10-04 12:00:12 +00:00
"github.com/stretchr/testify/require"
feat: retrieve balance history for tokens and cache it to DB Extends wallet module with the history package with the following components: BalanceDB (balance_db.go) - Keeps track of balance information (token count, block, block timestamp) for a token identity (chain, address, currency) - The cached data is stored in `balance_history` table. - Uniqueness constrained is enforced by the `balance_history_identify_entry` UNIQUE index. - Optimal DB fetching is ensured by the `balance_history_filter_entries` index Balance (balance.go) - Provides two stages: - Fetch of balance history using RPC calls (Balance.update function) - Retrieving of cached balance data from the DB it exists (Balance.get function) - Fetching and retrieving of data is done for specific time intervals defined by TimeInterval "enumeration" - Update process is done for a token identity by the Balance.Update function - The granularity of data points returned is defined by the constant increment step define in `timeIntervalToStride` for each time interval. - The `blocksStride` values have a common divisor to have cache hit between time intervals. Service (service.go) - Main APIs - StartBalanceHistory: Regularly updates balance history for all enabled networks, available accounts and provided tokens. - GetBalanceHistory: retrieves cached token count for a token identity (chain, address, currency) for multiple chains - UpdateVisibleTokens: will set the list of tokens to have historical balance fetched. This is a simplification to limit tokens to a small list that make sense Fetch balance history for ECR20 tokens - Add token.Manager.GetTokenBalanceAt to fetch balance of a specific block number of ECR20. - Add tokenChainClientSource concrete implementation of DataSource to fetch balance of ECR20 tokens. - Chose the correct DataSource implementation based on the token "is native" property. Tests Tests are implemented using a mock of `DataSource` interface used to intercept the RPC calls. Notes: - the timestamp used for retrieving block balance is constant Closes status-desktop: #8175, #8226, #8862
2022-11-15 12:14:41 +00:00
"github.com/ethereum/go-ethereum/common"
fix(tests): moved test db setup to a common place 't/helpers', created interface for initializing db, which is implemented for appdatabase and walletdatabase. TBD for multiaccounts DB. Unified DB initializion for all tests using helpers and new interface. Reduced sqlcipher kdf iterations for all tests to 1.
2023-08-11 11:28:45 +00:00
"github.com/status-im/status-go/t/helpers"
"github.com/status-im/status-go/walletdatabase"
feat: retrieve balance history for tokens and cache it to DB Extends wallet module with the history package with the following components: BalanceDB (balance_db.go) - Keeps track of balance information (token count, block, block timestamp) for a token identity (chain, address, currency) - The cached data is stored in `balance_history` table. - Uniqueness constrained is enforced by the `balance_history_identify_entry` UNIQUE index. - Optimal DB fetching is ensured by the `balance_history_filter_entries` index Balance (balance.go) - Provides two stages: - Fetch of balance history using RPC calls (Balance.update function) - Retrieving of cached balance data from the DB it exists (Balance.get function) - Fetching and retrieving of data is done for specific time intervals defined by TimeInterval "enumeration" - Update process is done for a token identity by the Balance.Update function - The granularity of data points returned is defined by the constant increment step define in `timeIntervalToStride` for each time interval. - The `blocksStride` values have a common divisor to have cache hit between time intervals. Service (service.go) - Main APIs - StartBalanceHistory: Regularly updates balance history for all enabled networks, available accounts and provided tokens. - GetBalanceHistory: retrieves cached token count for a token identity (chain, address, currency) for multiple chains - UpdateVisibleTokens: will set the list of tokens to have historical balance fetched. This is a simplification to limit tokens to a small list that make sense Fetch balance history for ECR20 tokens - Add token.Manager.GetTokenBalanceAt to fetch balance of a specific block number of ECR20. - Add tokenChainClientSource concrete implementation of DataSource to fetch balance of ECR20 tokens. - Chose the correct DataSource implementation based on the token "is native" property. Tests Tests are implemented using a mock of `DataSource` interface used to intercept the RPC calls. Notes: - the timestamp used for retrieving block balance is constant Closes status-desktop: #8175, #8226, #8862
2022-11-15 12:14:41 +00:00
)
Implemented balance history based on transfers (#4022) * feat(wallet): implement balance history based on fetched transfers * Added vendor 'ttlcache'
2023-10-04 12:00:12 +00:00
func newTestDB(t *testing.T) *BalanceDB {
fix(tests): moved test db setup to a common place 't/helpers', created interface for initializing db, which is implemented for appdatabase and walletdatabase. TBD for multiaccounts DB. Unified DB initializion for all tests using helpers and new interface. Reduced sqlcipher kdf iterations for all tests to 1.
2023-08-11 11:28:45 +00:00
db, err := helpers.SetupTestMemorySQLDB(walletdatabase.DbInitializer{})
feat: retrieve balance history for tokens and cache it to DB Extends wallet module with the history package with the following components: BalanceDB (balance_db.go) - Keeps track of balance information (token count, block, block timestamp) for a token identity (chain, address, currency) - The cached data is stored in `balance_history` table. - Uniqueness constrained is enforced by the `balance_history_identify_entry` UNIQUE index. - Optimal DB fetching is ensured by the `balance_history_filter_entries` index Balance (balance.go) - Provides two stages: - Fetch of balance history using RPC calls (Balance.update function) - Retrieving of cached balance data from the DB it exists (Balance.get function) - Fetching and retrieving of data is done for specific time intervals defined by TimeInterval "enumeration" - Update process is done for a token identity by the Balance.Update function - The granularity of data points returned is defined by the constant increment step define in `timeIntervalToStride` for each time interval. - The `blocksStride` values have a common divisor to have cache hit between time intervals. Service (service.go) - Main APIs - StartBalanceHistory: Regularly updates balance history for all enabled networks, available accounts and provided tokens. - GetBalanceHistory: retrieves cached token count for a token identity (chain, address, currency) for multiple chains - UpdateVisibleTokens: will set the list of tokens to have historical balance fetched. This is a simplification to limit tokens to a small list that make sense Fetch balance history for ECR20 tokens - Add token.Manager.GetTokenBalanceAt to fetch balance of a specific block number of ECR20. - Add tokenChainClientSource concrete implementation of DataSource to fetch balance of ECR20 tokens. - Chose the correct DataSource implementation based on the token "is native" property. Tests Tests are implemented using a mock of `DataSource` interface used to intercept the RPC calls. Notes: - the timestamp used for retrieving block balance is constant Closes status-desktop: #8175, #8226, #8862
2022-11-15 12:14:41 +00:00
require.NoError(t, err)
Implemented balance history based on transfers (#4022) * feat(wallet): implement balance history based on fetched transfers * Added vendor 'ttlcache'
2023-10-04 12:00:12 +00:00
return NewBalanceDB(db)
feat: retrieve balance history for tokens and cache it to DB Extends wallet module with the history package with the following components: BalanceDB (balance_db.go) - Keeps track of balance information (token count, block, block timestamp) for a token identity (chain, address, currency) - The cached data is stored in `balance_history` table. - Uniqueness constrained is enforced by the `balance_history_identify_entry` UNIQUE index. - Optimal DB fetching is ensured by the `balance_history_filter_entries` index Balance (balance.go) - Provides two stages: - Fetch of balance history using RPC calls (Balance.update function) - Retrieving of cached balance data from the DB it exists (Balance.get function) - Fetching and retrieving of data is done for specific time intervals defined by TimeInterval "enumeration" - Update process is done for a token identity by the Balance.Update function - The granularity of data points returned is defined by the constant increment step define in `timeIntervalToStride` for each time interval. - The `blocksStride` values have a common divisor to have cache hit between time intervals. Service (service.go) - Main APIs - StartBalanceHistory: Regularly updates balance history for all enabled networks, available accounts and provided tokens. - GetBalanceHistory: retrieves cached token count for a token identity (chain, address, currency) for multiple chains - UpdateVisibleTokens: will set the list of tokens to have historical balance fetched. This is a simplification to limit tokens to a small list that make sense Fetch balance history for ECR20 tokens - Add token.Manager.GetTokenBalanceAt to fetch balance of a specific block number of ECR20. - Add tokenChainClientSource concrete implementation of DataSource to fetch balance of ECR20 tokens. - Chose the correct DataSource implementation based on the token "is native" property. Tests Tests are implemented using a mock of `DataSource` interface used to intercept the RPC calls. Notes: - the timestamp used for retrieving block balance is constant Closes status-desktop: #8175, #8226, #8862
2022-11-15 12:14:41 +00:00
}
Implemented balance history based on transfers (#4022) * feat(wallet): implement balance history based on fetched transfers * Added vendor 'ttlcache'
2023-10-04 12:00:12 +00:00
func dbWithEntries(t *testing.T, entries []*entry) *BalanceDB {
db := newTestDB(t)
for _, entry := range entries {
err := db.add(entry)
require.NoError(t, err)
feat: retrieve balance history for tokens and cache it to DB Extends wallet module with the history package with the following components: BalanceDB (balance_db.go) - Keeps track of balance information (token count, block, block timestamp) for a token identity (chain, address, currency) - The cached data is stored in `balance_history` table. - Uniqueness constrained is enforced by the `balance_history_identify_entry` UNIQUE index. - Optimal DB fetching is ensured by the `balance_history_filter_entries` index Balance (balance.go) - Provides two stages: - Fetch of balance history using RPC calls (Balance.update function) - Retrieving of cached balance data from the DB it exists (Balance.get function) - Fetching and retrieving of data is done for specific time intervals defined by TimeInterval "enumeration" - Update process is done for a token identity by the Balance.Update function - The granularity of data points returned is defined by the constant increment step define in `timeIntervalToStride` for each time interval. - The `blocksStride` values have a common divisor to have cache hit between time intervals. Service (service.go) - Main APIs - StartBalanceHistory: Regularly updates balance history for all enabled networks, available accounts and provided tokens. - GetBalanceHistory: retrieves cached token count for a token identity (chain, address, currency) for multiple chains - UpdateVisibleTokens: will set the list of tokens to have historical balance fetched. This is a simplification to limit tokens to a small list that make sense Fetch balance history for ECR20 tokens - Add token.Manager.GetTokenBalanceAt to fetch balance of a specific block number of ECR20. - Add tokenChainClientSource concrete implementation of DataSource to fetch balance of ECR20 tokens. - Chose the correct DataSource implementation based on the token "is native" property. Tests Tests are implemented using a mock of `DataSource` interface used to intercept the RPC calls. Notes: - the timestamp used for retrieving block balance is constant Closes status-desktop: #8175, #8226, #8862
2022-11-15 12:14:41 +00:00
}
Implemented balance history based on transfers (#4022) * feat(wallet): implement balance history based on fetched transfers * Added vendor 'ttlcache'
2023-10-04 12:00:12 +00:00
return db
feat: retrieve balance history for tokens and cache it to DB Extends wallet module with the history package with the following components: BalanceDB (balance_db.go) - Keeps track of balance information (token count, block, block timestamp) for a token identity (chain, address, currency) - The cached data is stored in `balance_history` table. - Uniqueness constrained is enforced by the `balance_history_identify_entry` UNIQUE index. - Optimal DB fetching is ensured by the `balance_history_filter_entries` index Balance (balance.go) - Provides two stages: - Fetch of balance history using RPC calls (Balance.update function) - Retrieving of cached balance data from the DB it exists (Balance.get function) - Fetching and retrieving of data is done for specific time intervals defined by TimeInterval "enumeration" - Update process is done for a token identity by the Balance.Update function - The granularity of data points returned is defined by the constant increment step define in `timeIntervalToStride` for each time interval. - The `blocksStride` values have a common divisor to have cache hit between time intervals. Service (service.go) - Main APIs - StartBalanceHistory: Regularly updates balance history for all enabled networks, available accounts and provided tokens. - GetBalanceHistory: retrieves cached token count for a token identity (chain, address, currency) for multiple chains - UpdateVisibleTokens: will set the list of tokens to have historical balance fetched. This is a simplification to limit tokens to a small list that make sense Fetch balance history for ECR20 tokens - Add token.Manager.GetTokenBalanceAt to fetch balance of a specific block number of ECR20. - Add tokenChainClientSource concrete implementation of DataSource to fetch balance of ECR20 tokens. - Chose the correct DataSource implementation based on the token "is native" property. Tests Tests are implemented using a mock of `DataSource` interface used to intercept the RPC calls. Notes: - the timestamp used for retrieving block balance is constant Closes status-desktop: #8175, #8226, #8862
2022-11-15 12:14:41 +00:00
}
Implemented balance history based on transfers (#4022) * feat(wallet): implement balance history based on fetched transfers * Added vendor 'ttlcache'
2023-10-04 12:00:12 +00:00
func TestBalance_addPaddingPoints(t *testing.T) {
type args struct {
currency string
fix: Handle balance for all accounts (#4261)
2023-11-29 11:20:18 +00:00
addresses []common.Address
Implemented balance history based on transfers (#4022) * feat(wallet): implement balance history based on fetched transfers * Added vendor 'ttlcache'
2023-10-04 12:00:12 +00:00
fromTimestamp uint64
currentTimestamp uint64
data []*entry
limit int
feat: retrieve balance history for tokens and cache it to DB Extends wallet module with the history package with the following components: BalanceDB (balance_db.go) - Keeps track of balance information (token count, block, block timestamp) for a token identity (chain, address, currency) - The cached data is stored in `balance_history` table. - Uniqueness constrained is enforced by the `balance_history_identify_entry` UNIQUE index. - Optimal DB fetching is ensured by the `balance_history_filter_entries` index Balance (balance.go) - Provides two stages: - Fetch of balance history using RPC calls (Balance.update function) - Retrieving of cached balance data from the DB it exists (Balance.get function) - Fetching and retrieving of data is done for specific time intervals defined by TimeInterval "enumeration" - Update process is done for a token identity by the Balance.Update function - The granularity of data points returned is defined by the constant increment step define in `timeIntervalToStride` for each time interval. - The `blocksStride` values have a common divisor to have cache hit between time intervals. Service (service.go) - Main APIs - StartBalanceHistory: Regularly updates balance history for all enabled networks, available accounts and provided tokens. - GetBalanceHistory: retrieves cached token count for a token identity (chain, address, currency) for multiple chains - UpdateVisibleTokens: will set the list of tokens to have historical balance fetched. This is a simplification to limit tokens to a small list that make sense Fetch balance history for ECR20 tokens - Add token.Manager.GetTokenBalanceAt to fetch balance of a specific block number of ECR20. - Add tokenChainClientSource concrete implementation of DataSource to fetch balance of ECR20 tokens. - Chose the correct DataSource implementation based on the token "is native" property. Tests Tests are implemented using a mock of `DataSource` interface used to intercept the RPC calls. Notes: - the timestamp used for retrieving block balance is constant Closes status-desktop: #8175, #8226, #8862
2022-11-15 12:14:41 +00:00
}
Implemented balance history based on transfers (#4022) * feat(wallet): implement balance history based on fetched transfers * Added vendor 'ttlcache'
2023-10-04 12:00:12 +00:00
tests := []struct {
name string
args args
want []*entry
wantErr bool
feat: retrieve balance history for tokens and cache it to DB Extends wallet module with the history package with the following components: BalanceDB (balance_db.go) - Keeps track of balance information (token count, block, block timestamp) for a token identity (chain, address, currency) - The cached data is stored in `balance_history` table. - Uniqueness constrained is enforced by the `balance_history_identify_entry` UNIQUE index. - Optimal DB fetching is ensured by the `balance_history_filter_entries` index Balance (balance.go) - Provides two stages: - Fetch of balance history using RPC calls (Balance.update function) - Retrieving of cached balance data from the DB it exists (Balance.get function) - Fetching and retrieving of data is done for specific time intervals defined by TimeInterval "enumeration" - Update process is done for a token identity by the Balance.Update function - The granularity of data points returned is defined by the constant increment step define in `timeIntervalToStride` for each time interval. - The `blocksStride` values have a common divisor to have cache hit between time intervals. Service (service.go) - Main APIs - StartBalanceHistory: Regularly updates balance history for all enabled networks, available accounts and provided tokens. - GetBalanceHistory: retrieves cached token count for a token identity (chain, address, currency) for multiple chains - UpdateVisibleTokens: will set the list of tokens to have historical balance fetched. This is a simplification to limit tokens to a small list that make sense Fetch balance history for ECR20 tokens - Add token.Manager.GetTokenBalanceAt to fetch balance of a specific block number of ECR20. - Add tokenChainClientSource concrete implementation of DataSource to fetch balance of ECR20 tokens. - Chose the correct DataSource implementation based on the token "is native" property. Tests Tests are implemented using a mock of `DataSource` interface used to intercept the RPC calls. Notes: - the timestamp used for retrieving block balance is constant Closes status-desktop: #8175, #8226, #8862
2022-11-15 12:14:41 +00:00
}{
Implemented balance history based on transfers (#4022) * feat(wallet): implement balance history based on fetched transfers * Added vendor 'ttlcache'
2023-10-04 12:00:12 +00:00
{
name: "addOnePaddingPointAtMiddle",
args: args{
currency: "ETH",
fix: Handle balance for all accounts (#4261)
2023-11-29 11:20:18 +00:00
addresses: []common.Address{common.Address{1}},
Implemented balance history based on transfers (#4022) * feat(wallet): implement balance history based on fetched transfers * Added vendor 'ttlcache'
2023-10-04 12:00:12 +00:00
fromTimestamp: 0,
currentTimestamp: 2,
data: []*entry{
{
balance: big.NewInt(0),
timestamp: 0,
tokenSymbol: "ETH",
address: common.Address{1},
},
{
balance: big.NewInt(2),
timestamp: 2,
tokenSymbol: "ETH",
address: common.Address{1},
},
},
limit: 3,
},
want: []*entry{
{
balance: big.NewInt(0),
timestamp: 0,
tokenSymbol: "ETH",
address: common.Address{1},
},
{
balance: big.NewInt(0),
timestamp: 1,
tokenSymbol: "ETH",
address: common.Address{1},
},
{
balance: big.NewInt(2),
timestamp: 2,
tokenSymbol: "ETH",
address: common.Address{1},
},
},
wantErr: false,
},
{
name: "noPaddingEqualsLimit",
args: args{
currency: "ETH",
fix: Handle balance for all accounts (#4261)
2023-11-29 11:20:18 +00:00
addresses: []common.Address{common.Address{1}},
Implemented balance history based on transfers (#4022) * feat(wallet): implement balance history based on fetched transfers * Added vendor 'ttlcache'
2023-10-04 12:00:12 +00:00
fromTimestamp: 0,
currentTimestamp: 2,
data: []*entry{
{
balance: big.NewInt(0),
timestamp: 0,
block: big.NewInt(1),
tokenSymbol: "ETH",
address: common.Address{1},
},
{
balance: big.NewInt(1),
timestamp: 2,
block: big.NewInt(2),
tokenSymbol: "ETH",
address: common.Address{1},
},
},
limit: 2,
},
want: []*entry{
{
balance: big.NewInt(0),
timestamp: 0,
block: big.NewInt(1),
tokenSymbol: "ETH",
address: common.Address{1},
},
{
balance: big.NewInt(1),
timestamp: 2,
block: big.NewInt(2),
tokenSymbol: "ETH",
address: common.Address{1},
},
},
wantErr: false,
},
{
name: "limitLessThanDataSize",
args: args{
currency: "ETH",
fix: Handle balance for all accounts (#4261)
2023-11-29 11:20:18 +00:00
addresses: []common.Address{common.Address{1}},
Implemented balance history based on transfers (#4022) * feat(wallet): implement balance history based on fetched transfers * Added vendor 'ttlcache'
2023-10-04 12:00:12 +00:00
fromTimestamp: 0,
currentTimestamp: 2,
data: []*entry{
{
balance: big.NewInt(0),
timestamp: 0,
block: big.NewInt(1),
tokenSymbol: "ETH",
address: common.Address{1},
},
{
balance: big.NewInt(1),
timestamp: 2,
block: big.NewInt(2),
tokenSymbol: "ETH",
address: common.Address{1},
},
},
limit: 1,
},
want: []*entry{
{
balance: big.NewInt(0),
timestamp: 0,
block: big.NewInt(1),
tokenSymbol: "ETH",
address: common.Address{1},
},
{
balance: big.NewInt(1),
timestamp: 2,
block: big.NewInt(2),
tokenSymbol: "ETH",
address: common.Address{1},
},
},
wantErr: false,
},
{
name: "addMultiplePaddingPoints",
args: args{
currency: "ETH",
fix: Handle balance for all accounts (#4261)
2023-11-29 11:20:18 +00:00
addresses: []common.Address{common.Address{1}},
Implemented balance history based on transfers (#4022) * feat(wallet): implement balance history based on fetched transfers * Added vendor 'ttlcache'
2023-10-04 12:00:12 +00:00
fromTimestamp: 1,
currentTimestamp: 5,
data: []*entry{
{
balance: big.NewInt(0),
timestamp: 1,
tokenSymbol: "ETH",
address: common.Address{1},
},
{
balance: big.NewInt(4),
timestamp: 4,
tokenSymbol: "ETH",
address: common.Address{1},
},
{
balance: big.NewInt(5),
timestamp: 5,
tokenSymbol: "ETH",
address: common.Address{1},
},
},
limit: 5,
},
want: []*entry{
{
balance: big.NewInt(0),
timestamp: 1,
tokenSymbol: "ETH",
address: common.Address{1},
},
{
balance: big.NewInt(0),
timestamp: 2,
tokenSymbol: "ETH",
address: common.Address{1},
},
{
balance: big.NewInt(0),
timestamp: 3,
tokenSymbol: "ETH",
address: common.Address{1},
},
{
balance: big.NewInt(4),
timestamp: 4,
tokenSymbol: "ETH",
address: common.Address{1},
},
{
balance: big.NewInt(5),
timestamp: 5,
tokenSymbol: "ETH",
address: common.Address{1},
},
},
wantErr: false,
},
{
name: "addMultiplePaddingPointsDuplicateTimestamps",
args: args{
currency: "ETH",
fix: Handle balance for all accounts (#4261)
2023-11-29 11:20:18 +00:00
addresses: []common.Address{common.Address{1}},
Implemented balance history based on transfers (#4022) * feat(wallet): implement balance history based on fetched transfers * Added vendor 'ttlcache'
2023-10-04 12:00:12 +00:00
fromTimestamp: 1,
currentTimestamp: 5,
data: []*entry{
{
balance: big.NewInt(0),
timestamp: 1,
tokenSymbol: "ETH",
address: common.Address{1},
},
{
balance: big.NewInt(0),
timestamp: 1,
tokenSymbol: "ETH",
address: common.Address{1},
},
{
balance: big.NewInt(4),
timestamp: 4,
tokenSymbol: "ETH",
address: common.Address{1},
},
{
balance: big.NewInt(5),
timestamp: 5,
tokenSymbol: "ETH",
address: common.Address{1},
},
},
limit: 5,
},
want: []*entry{
{
balance: big.NewInt(0),
timestamp: 1,
tokenSymbol: "ETH",
address: common.Address{1},
},
{
balance: big.NewInt(0),
timestamp: 1,
tokenSymbol: "ETH",
address: common.Address{1},
},
{
balance: big.NewInt(0),
timestamp: 2,
tokenSymbol: "ETH",
address: common.Address{1},
},
{
balance: big.NewInt(4),
timestamp: 4,
tokenSymbol: "ETH",
address: common.Address{1},
},
{
balance: big.NewInt(5),
timestamp: 5,
tokenSymbol: "ETH",
address: common.Address{1},
},
},
wantErr: false,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
fix: Handle balance for all accounts (#4261)
2023-11-29 11:20:18 +00:00
gotRes, err := addPaddingPoints(tt.args.currency, tt.args.addresses, tt.args.currentTimestamp, tt.args.data, tt.args.limit)
Implemented balance history based on transfers (#4022) * feat(wallet): implement balance history based on fetched transfers * Added vendor 'ttlcache'
2023-10-04 12:00:12 +00:00
if (err != nil) != tt.wantErr {
t.Errorf("Balance.addPaddingPoints() error = %v, wantErr %v", err, tt.wantErr)
return
feat: retrieve balance history for tokens and cache it to DB Extends wallet module with the history package with the following components: BalanceDB (balance_db.go) - Keeps track of balance information (token count, block, block timestamp) for a token identity (chain, address, currency) - The cached data is stored in `balance_history` table. - Uniqueness constrained is enforced by the `balance_history_identify_entry` UNIQUE index. - Optimal DB fetching is ensured by the `balance_history_filter_entries` index Balance (balance.go) - Provides two stages: - Fetch of balance history using RPC calls (Balance.update function) - Retrieving of cached balance data from the DB it exists (Balance.get function) - Fetching and retrieving of data is done for specific time intervals defined by TimeInterval "enumeration" - Update process is done for a token identity by the Balance.Update function - The granularity of data points returned is defined by the constant increment step define in `timeIntervalToStride` for each time interval. - The `blocksStride` values have a common divisor to have cache hit between time intervals. Service (service.go) - Main APIs - StartBalanceHistory: Regularly updates balance history for all enabled networks, available accounts and provided tokens. - GetBalanceHistory: retrieves cached token count for a token identity (chain, address, currency) for multiple chains - UpdateVisibleTokens: will set the list of tokens to have historical balance fetched. This is a simplification to limit tokens to a small list that make sense Fetch balance history for ECR20 tokens - Add token.Manager.GetTokenBalanceAt to fetch balance of a specific block number of ECR20. - Add tokenChainClientSource concrete implementation of DataSource to fetch balance of ECR20 tokens. - Chose the correct DataSource implementation based on the token "is native" property. Tests Tests are implemented using a mock of `DataSource` interface used to intercept the RPC calls. Notes: - the timestamp used for retrieving block balance is constant Closes status-desktop: #8175, #8226, #8862
2022-11-15 12:14:41 +00:00
}
Implemented balance history based on transfers (#4022) * feat(wallet): implement balance history based on fetched transfers * Added vendor 'ttlcache'
2023-10-04 12:00:12 +00:00
if !reflect.DeepEqual(gotRes, tt.want) {
t.Errorf("Balance.addPaddingPoints() = %v, want %v", gotRes, tt.want)
feat: retrieve balance history for tokens and cache it to DB Extends wallet module with the history package with the following components: BalanceDB (balance_db.go) - Keeps track of balance information (token count, block, block timestamp) for a token identity (chain, address, currency) - The cached data is stored in `balance_history` table. - Uniqueness constrained is enforced by the `balance_history_identify_entry` UNIQUE index. - Optimal DB fetching is ensured by the `balance_history_filter_entries` index Balance (balance.go) - Provides two stages: - Fetch of balance history using RPC calls (Balance.update function) - Retrieving of cached balance data from the DB it exists (Balance.get function) - Fetching and retrieving of data is done for specific time intervals defined by TimeInterval "enumeration" - Update process is done for a token identity by the Balance.Update function - The granularity of data points returned is defined by the constant increment step define in `timeIntervalToStride` for each time interval. - The `blocksStride` values have a common divisor to have cache hit between time intervals. Service (service.go) - Main APIs - StartBalanceHistory: Regularly updates balance history for all enabled networks, available accounts and provided tokens. - GetBalanceHistory: retrieves cached token count for a token identity (chain, address, currency) for multiple chains - UpdateVisibleTokens: will set the list of tokens to have historical balance fetched. This is a simplification to limit tokens to a small list that make sense Fetch balance history for ECR20 tokens - Add token.Manager.GetTokenBalanceAt to fetch balance of a specific block number of ECR20. - Add tokenChainClientSource concrete implementation of DataSource to fetch balance of ECR20 tokens. - Chose the correct DataSource implementation based on the token "is native" property. Tests Tests are implemented using a mock of `DataSource` interface used to intercept the RPC calls. Notes: - the timestamp used for retrieving block balance is constant Closes status-desktop: #8175, #8226, #8862
2022-11-15 12:14:41 +00:00
}
})
}
}
Implemented balance history based on transfers (#4022) * feat(wallet): implement balance history based on fetched transfers * Added vendor 'ttlcache'
2023-10-04 12:00:12 +00:00
func TestBalance_addEdgePoints(t *testing.T) {
feat: retrieve balance history for tokens and cache it to DB Extends wallet module with the history package with the following components: BalanceDB (balance_db.go) - Keeps track of balance information (token count, block, block timestamp) for a token identity (chain, address, currency) - The cached data is stored in `balance_history` table. - Uniqueness constrained is enforced by the `balance_history_identify_entry` UNIQUE index. - Optimal DB fetching is ensured by the `balance_history_filter_entries` index Balance (balance.go) - Provides two stages: - Fetch of balance history using RPC calls (Balance.update function) - Retrieving of cached balance data from the DB it exists (Balance.get function) - Fetching and retrieving of data is done for specific time intervals defined by TimeInterval "enumeration" - Update process is done for a token identity by the Balance.Update function - The granularity of data points returned is defined by the constant increment step define in `timeIntervalToStride` for each time interval. - The `blocksStride` values have a common divisor to have cache hit between time intervals. Service (service.go) - Main APIs - StartBalanceHistory: Regularly updates balance history for all enabled networks, available accounts and provided tokens. - GetBalanceHistory: retrieves cached token count for a token identity (chain, address, currency) for multiple chains - UpdateVisibleTokens: will set the list of tokens to have historical balance fetched. This is a simplification to limit tokens to a small list that make sense Fetch balance history for ECR20 tokens - Add token.Manager.GetTokenBalanceAt to fetch balance of a specific block number of ECR20. - Add tokenChainClientSource concrete implementation of DataSource to fetch balance of ECR20 tokens. - Chose the correct DataSource implementation based on the token "is native" property. Tests Tests are implemented using a mock of `DataSource` interface used to intercept the RPC calls. Notes: - the timestamp used for retrieving block balance is constant Closes status-desktop: #8175, #8226, #8862
2022-11-15 12:14:41 +00:00
Implemented balance history based on transfers (#4022) * feat(wallet): implement balance history based on fetched transfers * Added vendor 'ttlcache'
2023-10-04 12:00:12 +00:00
walletDB := newTestDB(t)
feat: retrieve balance history for tokens and cache it to DB Extends wallet module with the history package with the following components: BalanceDB (balance_db.go) - Keeps track of balance information (token count, block, block timestamp) for a token identity (chain, address, currency) - The cached data is stored in `balance_history` table. - Uniqueness constrained is enforced by the `balance_history_identify_entry` UNIQUE index. - Optimal DB fetching is ensured by the `balance_history_filter_entries` index Balance (balance.go) - Provides two stages: - Fetch of balance history using RPC calls (Balance.update function) - Retrieving of cached balance data from the DB it exists (Balance.get function) - Fetching and retrieving of data is done for specific time intervals defined by TimeInterval "enumeration" - Update process is done for a token identity by the Balance.Update function - The granularity of data points returned is defined by the constant increment step define in `timeIntervalToStride` for each time interval. - The `blocksStride` values have a common divisor to have cache hit between time intervals. Service (service.go) - Main APIs - StartBalanceHistory: Regularly updates balance history for all enabled networks, available accounts and provided tokens. - GetBalanceHistory: retrieves cached token count for a token identity (chain, address, currency) for multiple chains - UpdateVisibleTokens: will set the list of tokens to have historical balance fetched. This is a simplification to limit tokens to a small list that make sense Fetch balance history for ECR20 tokens - Add token.Manager.GetTokenBalanceAt to fetch balance of a specific block number of ECR20. - Add tokenChainClientSource concrete implementation of DataSource to fetch balance of ECR20 tokens. - Chose the correct DataSource implementation based on the token "is native" property. Tests Tests are implemented using a mock of `DataSource` interface used to intercept the RPC calls. Notes: - the timestamp used for retrieving block balance is constant Closes status-desktop: #8175, #8226, #8862
2022-11-15 12:14:41 +00:00
Implemented balance history based on transfers (#4022) * feat(wallet): implement balance history based on fetched transfers * Added vendor 'ttlcache'
2023-10-04 12:00:12 +00:00
type fields struct {
db *BalanceDB
feat: retrieve balance history for tokens and cache it to DB Extends wallet module with the history package with the following components: BalanceDB (balance_db.go) - Keeps track of balance information (token count, block, block timestamp) for a token identity (chain, address, currency) - The cached data is stored in `balance_history` table. - Uniqueness constrained is enforced by the `balance_history_identify_entry` UNIQUE index. - Optimal DB fetching is ensured by the `balance_history_filter_entries` index Balance (balance.go) - Provides two stages: - Fetch of balance history using RPC calls (Balance.update function) - Retrieving of cached balance data from the DB it exists (Balance.get function) - Fetching and retrieving of data is done for specific time intervals defined by TimeInterval "enumeration" - Update process is done for a token identity by the Balance.Update function - The granularity of data points returned is defined by the constant increment step define in `timeIntervalToStride` for each time interval. - The `blocksStride` values have a common divisor to have cache hit between time intervals. Service (service.go) - Main APIs - StartBalanceHistory: Regularly updates balance history for all enabled networks, available accounts and provided tokens. - GetBalanceHistory: retrieves cached token count for a token identity (chain, address, currency) for multiple chains - UpdateVisibleTokens: will set the list of tokens to have historical balance fetched. This is a simplification to limit tokens to a small list that make sense Fetch balance history for ECR20 tokens - Add token.Manager.GetTokenBalanceAt to fetch balance of a specific block number of ECR20. - Add tokenChainClientSource concrete implementation of DataSource to fetch balance of ECR20 tokens. - Chose the correct DataSource implementation based on the token "is native" property. Tests Tests are implemented using a mock of `DataSource` interface used to intercept the RPC calls. Notes: - the timestamp used for retrieving block balance is constant Closes status-desktop: #8175, #8226, #8862
2022-11-15 12:14:41 +00:00
}
Implemented balance history based on transfers (#4022) * feat(wallet): implement balance history based on fetched transfers * Added vendor 'ttlcache'
2023-10-04 12:00:12 +00:00
type args struct {
chainID uint64
currency string
fix: Handle balance for all accounts (#4261)
2023-11-29 11:20:18 +00:00
addresses []common.Address
Implemented balance history based on transfers (#4022) * feat(wallet): implement balance history based on fetched transfers * Added vendor 'ttlcache'
2023-10-04 12:00:12 +00:00
fromTimestamp uint64
toTimestamp uint64
data []*entry
feat: retrieve balance history for tokens and cache it to DB Extends wallet module with the history package with the following components: BalanceDB (balance_db.go) - Keeps track of balance information (token count, block, block timestamp) for a token identity (chain, address, currency) - The cached data is stored in `balance_history` table. - Uniqueness constrained is enforced by the `balance_history_identify_entry` UNIQUE index. - Optimal DB fetching is ensured by the `balance_history_filter_entries` index Balance (balance.go) - Provides two stages: - Fetch of balance history using RPC calls (Balance.update function) - Retrieving of cached balance data from the DB it exists (Balance.get function) - Fetching and retrieving of data is done for specific time intervals defined by TimeInterval "enumeration" - Update process is done for a token identity by the Balance.Update function - The granularity of data points returned is defined by the constant increment step define in `timeIntervalToStride` for each time interval. - The `blocksStride` values have a common divisor to have cache hit between time intervals. Service (service.go) - Main APIs - StartBalanceHistory: Regularly updates balance history for all enabled networks, available accounts and provided tokens. - GetBalanceHistory: retrieves cached token count for a token identity (chain, address, currency) for multiple chains - UpdateVisibleTokens: will set the list of tokens to have historical balance fetched. This is a simplification to limit tokens to a small list that make sense Fetch balance history for ECR20 tokens - Add token.Manager.GetTokenBalanceAt to fetch balance of a specific block number of ECR20. - Add tokenChainClientSource concrete implementation of DataSource to fetch balance of ECR20 tokens. - Chose the correct DataSource implementation based on the token "is native" property. Tests Tests are implemented using a mock of `DataSource` interface used to intercept the RPC calls. Notes: - the timestamp used for retrieving block balance is constant Closes status-desktop: #8175, #8226, #8862
2022-11-15 12:14:41 +00:00
}
Implemented balance history based on transfers (#4022) * feat(wallet): implement balance history based on fetched transfers * Added vendor 'ttlcache'
2023-10-04 12:00:12 +00:00
tests := []struct {
name string
fields fields
args args
wantRes []*entry
wantErr bool
feat: retrieve balance history for tokens and cache it to DB Extends wallet module with the history package with the following components: BalanceDB (balance_db.go) - Keeps track of balance information (token count, block, block timestamp) for a token identity (chain, address, currency) - The cached data is stored in `balance_history` table. - Uniqueness constrained is enforced by the `balance_history_identify_entry` UNIQUE index. - Optimal DB fetching is ensured by the `balance_history_filter_entries` index Balance (balance.go) - Provides two stages: - Fetch of balance history using RPC calls (Balance.update function) - Retrieving of cached balance data from the DB it exists (Balance.get function) - Fetching and retrieving of data is done for specific time intervals defined by TimeInterval "enumeration" - Update process is done for a token identity by the Balance.Update function - The granularity of data points returned is defined by the constant increment step define in `timeIntervalToStride` for each time interval. - The `blocksStride` values have a common divisor to have cache hit between time intervals. Service (service.go) - Main APIs - StartBalanceHistory: Regularly updates balance history for all enabled networks, available accounts and provided tokens. - GetBalanceHistory: retrieves cached token count for a token identity (chain, address, currency) for multiple chains - UpdateVisibleTokens: will set the list of tokens to have historical balance fetched. This is a simplification to limit tokens to a small list that make sense Fetch balance history for ECR20 tokens - Add token.Manager.GetTokenBalanceAt to fetch balance of a specific block number of ECR20. - Add tokenChainClientSource concrete implementation of DataSource to fetch balance of ECR20 tokens. - Chose the correct DataSource implementation based on the token "is native" property. Tests Tests are implemented using a mock of `DataSource` interface used to intercept the RPC calls. Notes: - the timestamp used for retrieving block balance is constant Closes status-desktop: #8175, #8226, #8862
2022-11-15 12:14:41 +00:00
}{
Implemented balance history based on transfers (#4022) * feat(wallet): implement balance history based on fetched transfers * Added vendor 'ttlcache'
2023-10-04 12:00:12 +00:00
{
name: "addToEmptyData",
fields: fields{
db: walletDB,
},
args: args{
chainID: 111,
currency: "SNT",
fix: Handle balance for all accounts (#4261)
2023-11-29 11:20:18 +00:00
addresses: []common.Address{common.Address{1}},
Implemented balance history based on transfers (#4022) * feat(wallet): implement balance history based on fetched transfers * Added vendor 'ttlcache'
2023-10-04 12:00:12 +00:00
fromTimestamp: 1,
toTimestamp: 2,
data: []*entry{},
},
wantRes: []*entry{
{
chainID: 111,
balance: big.NewInt(0),
timestamp: 1,
tokenSymbol: "SNT",
address: common.Address{1},
},
{
chainID: 111,
balance: big.NewInt(0),
timestamp: 2,
tokenSymbol: "SNT",
address: common.Address{1},
},
},
wantErr: false,
},
{
name: "addToEmptyDataSinceGenesis",
fields: fields{
db: walletDB,
},
args: args{
chainID: 111,
currency: "SNT",
fix: Handle balance for all accounts (#4261)
2023-11-29 11:20:18 +00:00
addresses: []common.Address{common.Address{1}},
Implemented balance history based on transfers (#4022) * feat(wallet): implement balance history based on fetched transfers * Added vendor 'ttlcache'
2023-10-04 12:00:12 +00:00
fromTimestamp: 0, // will set to genesisTimestamp
toTimestamp: genesisTimestamp + 1,
data: []*entry{},
},
wantRes: []*entry{
{
chainID: 111,
balance: big.NewInt(0),
timestamp: genesisTimestamp,
tokenSymbol: "SNT",
address: common.Address{1},
},
{
chainID: 111,
balance: big.NewInt(0),
timestamp: genesisTimestamp + 1,
tokenSymbol: "SNT",
address: common.Address{1},
},
},
wantErr: false,
},
{
name: "addToNonEmptyDataFromPreviousEntry",
fields: fields{
db: dbWithEntries(t, []*entry{
{
chainID: 111,
balance: big.NewInt(1),
timestamp: 1,
block: big.NewInt(1),
tokenSymbol: "SNT",
address: common.Address{1},
},
}),
},
args: args{
chainID: 111,
currency: "SNT",
fix: Handle balance for all accounts (#4261)
2023-11-29 11:20:18 +00:00
addresses: []common.Address{common.Address{1}},
Implemented balance history based on transfers (#4022) * feat(wallet): implement balance history based on fetched transfers * Added vendor 'ttlcache'
2023-10-04 12:00:12 +00:00
fromTimestamp: 2,
toTimestamp: 4,
data: []*entry{
{
chainID: 111,
balance: big.NewInt(3),
timestamp: 3,
block: big.NewInt(3),
tokenSymbol: "SNT",
address: common.Address{1},
},
{
chainID: 111,
balance: big.NewInt(2),
timestamp: 4,
block: big.NewInt(4),
tokenSymbol: "SNT",
address: common.Address{1},
},
},
},
wantRes: []*entry{
{
chainID: 111,
balance: big.NewInt(1),
timestamp: 2,
tokenSymbol: "SNT",
address: common.Address{1},
},
{
chainID: 111,
balance: big.NewInt(3),
timestamp: 3,
block: big.NewInt(3),
tokenSymbol: "SNT",
address: common.Address{1},
},
{
chainID: 111,
balance: big.NewInt(2),
timestamp: 4,
block: big.NewInt(4),
tokenSymbol: "SNT",
address: common.Address{1},
},
},
wantErr: false,
},
fix(wallet)_: no balance chart for tokens, due to wrong symbol (ETH) used instead. Fixed padding points being removed from final result, regression. Edge points not added per address as it does not make sense. Fixed padding points number with respect to edge points number. Padding points now duplicate previous entry. Fixed timestamp boundaries to ignore addresses, as we want the whole range for all passed addresses. Fixed missing indices in balance_history table and clean up of duplicate rows. Removed ERC1155 from balance history sql query
2024-07-16 14:02:52 +00:00
{
name: "addToNonEmptyData",
fields: fields{
db: walletDB,
},
args: args{
chainID: 111,
currency: "SNT",
addresses: []common.Address{common.Address{1}},
fromTimestamp: 1,
toTimestamp: 2,
data: []*entry{
{
chainID: 111,
balance: big.NewInt(2),
timestamp: 2,
block: big.NewInt(2),
tokenSymbol: "SNT",
address: common.Address{1},
},
},
},
wantRes: []*entry{
{
chainID: 111,
balance: big.NewInt(0),
timestamp: 1,
tokenSymbol: "SNT",
address: common.Address{1},
},
{
chainID: 111,
balance: big.NewInt(2),
timestamp: 2,
block: big.NewInt(2),
tokenSymbol: "SNT",
address: common.Address{1},
},
},
wantErr: false,
},
Implemented balance history based on transfers (#4022) * feat(wallet): implement balance history based on fetched transfers * Added vendor 'ttlcache'
2023-10-04 12:00:12 +00:00
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
b := &Balance{
db: tt.fields.db,
feat: retrieve balance history for tokens and cache it to DB Extends wallet module with the history package with the following components: BalanceDB (balance_db.go) - Keeps track of balance information (token count, block, block timestamp) for a token identity (chain, address, currency) - The cached data is stored in `balance_history` table. - Uniqueness constrained is enforced by the `balance_history_identify_entry` UNIQUE index. - Optimal DB fetching is ensured by the `balance_history_filter_entries` index Balance (balance.go) - Provides two stages: - Fetch of balance history using RPC calls (Balance.update function) - Retrieving of cached balance data from the DB it exists (Balance.get function) - Fetching and retrieving of data is done for specific time intervals defined by TimeInterval "enumeration" - Update process is done for a token identity by the Balance.Update function - The granularity of data points returned is defined by the constant increment step define in `timeIntervalToStride` for each time interval. - The `blocksStride` values have a common divisor to have cache hit between time intervals. Service (service.go) - Main APIs - StartBalanceHistory: Regularly updates balance history for all enabled networks, available accounts and provided tokens. - GetBalanceHistory: retrieves cached token count for a token identity (chain, address, currency) for multiple chains - UpdateVisibleTokens: will set the list of tokens to have historical balance fetched. This is a simplification to limit tokens to a small list that make sense Fetch balance history for ECR20 tokens - Add token.Manager.GetTokenBalanceAt to fetch balance of a specific block number of ECR20. - Add tokenChainClientSource concrete implementation of DataSource to fetch balance of ECR20 tokens. - Chose the correct DataSource implementation based on the token "is native" property. Tests Tests are implemented using a mock of `DataSource` interface used to intercept the RPC calls. Notes: - the timestamp used for retrieving block balance is constant Closes status-desktop: #8175, #8226, #8862
2022-11-15 12:14:41 +00:00
}
fix: Handle balance for all accounts (#4261)
2023-11-29 11:20:18 +00:00
gotRes, err := b.addEdgePoints(tt.args.chainID, tt.args.currency, tt.args.addresses, tt.args.fromTimestamp, tt.args.toTimestamp, tt.args.data)
Implemented balance history based on transfers (#4022) * feat(wallet): implement balance history based on fetched transfers * Added vendor 'ttlcache'
2023-10-04 12:00:12 +00:00
if (err != nil) != tt.wantErr {
t.Errorf("Balance.addEdgePoints() error = %v, wantErr %v", err, tt.wantErr)
return
feat: retrieve balance history for tokens and cache it to DB Extends wallet module with the history package with the following components: BalanceDB (balance_db.go) - Keeps track of balance information (token count, block, block timestamp) for a token identity (chain, address, currency) - The cached data is stored in `balance_history` table. - Uniqueness constrained is enforced by the `balance_history_identify_entry` UNIQUE index. - Optimal DB fetching is ensured by the `balance_history_filter_entries` index Balance (balance.go) - Provides two stages: - Fetch of balance history using RPC calls (Balance.update function) - Retrieving of cached balance data from the DB it exists (Balance.get function) - Fetching and retrieving of data is done for specific time intervals defined by TimeInterval "enumeration" - Update process is done for a token identity by the Balance.Update function - The granularity of data points returned is defined by the constant increment step define in `timeIntervalToStride` for each time interval. - The `blocksStride` values have a common divisor to have cache hit between time intervals. Service (service.go) - Main APIs - StartBalanceHistory: Regularly updates balance history for all enabled networks, available accounts and provided tokens. - GetBalanceHistory: retrieves cached token count for a token identity (chain, address, currency) for multiple chains - UpdateVisibleTokens: will set the list of tokens to have historical balance fetched. This is a simplification to limit tokens to a small list that make sense Fetch balance history for ECR20 tokens - Add token.Manager.GetTokenBalanceAt to fetch balance of a specific block number of ECR20. - Add tokenChainClientSource concrete implementation of DataSource to fetch balance of ECR20 tokens. - Chose the correct DataSource implementation based on the token "is native" property. Tests Tests are implemented using a mock of `DataSource` interface used to intercept the RPC calls. Notes: - the timestamp used for retrieving block balance is constant Closes status-desktop: #8175, #8226, #8862
2022-11-15 12:14:41 +00:00
}
Implemented balance history based on transfers (#4022) * feat(wallet): implement balance history based on fetched transfers * Added vendor 'ttlcache'
2023-10-04 12:00:12 +00:00
if !reflect.DeepEqual(gotRes, tt.wantRes) {
t.Errorf("Balance.addEdgePoints() = \n%v,\nwant \n%v", gotRes, tt.wantRes)
feat: retrieve balance history for tokens and cache it to DB Extends wallet module with the history package with the following components: BalanceDB (balance_db.go) - Keeps track of balance information (token count, block, block timestamp) for a token identity (chain, address, currency) - The cached data is stored in `balance_history` table. - Uniqueness constrained is enforced by the `balance_history_identify_entry` UNIQUE index. - Optimal DB fetching is ensured by the `balance_history_filter_entries` index Balance (balance.go) - Provides two stages: - Fetch of balance history using RPC calls (Balance.update function) - Retrieving of cached balance data from the DB it exists (Balance.get function) - Fetching and retrieving of data is done for specific time intervals defined by TimeInterval "enumeration" - Update process is done for a token identity by the Balance.Update function - The granularity of data points returned is defined by the constant increment step define in `timeIntervalToStride` for each time interval. - The `blocksStride` values have a common divisor to have cache hit between time intervals. Service (service.go) - Main APIs - StartBalanceHistory: Regularly updates balance history for all enabled networks, available accounts and provided tokens. - GetBalanceHistory: retrieves cached token count for a token identity (chain, address, currency) for multiple chains - UpdateVisibleTokens: will set the list of tokens to have historical balance fetched. This is a simplification to limit tokens to a small list that make sense Fetch balance history for ECR20 tokens - Add token.Manager.GetTokenBalanceAt to fetch balance of a specific block number of ECR20. - Add tokenChainClientSource concrete implementation of DataSource to fetch balance of ECR20 tokens. - Chose the correct DataSource implementation based on the token "is native" property. Tests Tests are implemented using a mock of `DataSource` interface used to intercept the RPC calls. Notes: - the timestamp used for retrieving block balance is constant Closes status-desktop: #8175, #8226, #8862
2022-11-15 12:14:41 +00:00
}
})
}
}