forked from cerc-io/ipld-eth-server
remove pkg/transformers; extract shared files needed to
libraries/shared; work on automated db migration management
This commit is contained in:
Ian Norden
@@ -1,241 +0,0 @@
|
||||
package vat
|
||||
|
||||
import (
|
||||
"github.com/ethereum/go-ethereum/common"
|
||||
"github.com/vulcanize/vulcanizedb/pkg/datastore/postgres"
|
||||
"github.com/vulcanize/vulcanizedb/pkg/transformers/storage_diffs"
|
||||
"github.com/vulcanize/vulcanizedb/pkg/transformers/storage_diffs/maker"
|
||||
"github.com/vulcanize/vulcanizedb/pkg/transformers/storage_diffs/shared"
|
||||
)
|
||||
|
||||
const (
|
||||
Dai = "dai"
|
||||
Gem = "gem"
|
||||
IlkArt = "Art"
|
||||
IlkInk = "Ink"
|
||||
IlkRate = "rate"
|
||||
IlkTake = "take"
|
||||
Sin = "sin"
|
||||
UrnArt = "art"
|
||||
UrnInk = "ink"
|
||||
VatDebt = "debt"
|
||||
VatVice = "vice"
|
||||
)
|
||||
|
||||
var (
|
||||
DebtKey = common.HexToHash(storage_diffs.IndexSix)
|
||||
DebtMetadata = shared.StorageValueMetadata{
|
||||
Name: VatDebt,
|
||||
Keys: nil,
|
||||
Type: 0,
|
||||
}
|
||||
|
||||
IlksMappingIndex = storage_diffs.IndexOne
|
||||
UrnsMappingIndex = storage_diffs.IndexTwo
|
||||
GemsMappingIndex = storage_diffs.IndexThree
|
||||
DaiMappingIndex = storage_diffs.IndexFour
|
||||
SinMappingIndex = storage_diffs.IndexFive
|
||||
|
||||
ViceKey = common.HexToHash(storage_diffs.IndexSeven)
|
||||
ViceMetadata = shared.StorageValueMetadata{
|
||||
Name: VatVice,
|
||||
Keys: nil,
|
||||
Type: 0,
|
||||
}
|
||||
)
|
||||
|
||||
type VatMappings struct {
|
||||
StorageRepository maker.IMakerStorageRepository
|
||||
mappings map[common.Hash]shared.StorageValueMetadata
|
||||
}
|
||||
|
||||
func (mappings VatMappings) Lookup(key common.Hash) (shared.StorageValueMetadata, error) {
|
||||
metadata, ok := mappings.mappings[key]
|
||||
if !ok {
|
||||
err := mappings.loadMappings()
|
||||
if err != nil {
|
||||
return metadata, err
|
||||
}
|
||||
metadata, ok = mappings.mappings[key]
|
||||
if !ok {
|
||||
return metadata, shared.ErrStorageKeyNotFound{Key: key.Hex()}
|
||||
}
|
||||
}
|
||||
return metadata, nil
|
||||
}
|
||||
|
||||
func (mappings *VatMappings) SetDB(db *postgres.DB) {
|
||||
mappings.StorageRepository.SetDB(db)
|
||||
}
|
||||
|
||||
func (mappings *VatMappings) loadMappings() error {
|
||||
mappings.mappings = loadStaticMappings()
|
||||
daiErr := mappings.loadDaiKeys()
|
||||
if daiErr != nil {
|
||||
return daiErr
|
||||
}
|
||||
gemErr := mappings.loadGemKeys()
|
||||
if gemErr != nil {
|
||||
return gemErr
|
||||
}
|
||||
ilkErr := mappings.loadIlkKeys()
|
||||
if ilkErr != nil {
|
||||
return ilkErr
|
||||
}
|
||||
sinErr := mappings.loadSinKeys()
|
||||
if sinErr != nil {
|
||||
return sinErr
|
||||
}
|
||||
urnErr := mappings.loadUrnKeys()
|
||||
if urnErr != nil {
|
||||
return urnErr
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func loadStaticMappings() map[common.Hash]shared.StorageValueMetadata {
|
||||
mappings := make(map[common.Hash]shared.StorageValueMetadata)
|
||||
mappings[DebtKey] = DebtMetadata
|
||||
mappings[ViceKey] = ViceMetadata
|
||||
return mappings
|
||||
}
|
||||
|
||||
func (mappings *VatMappings) loadDaiKeys() error {
|
||||
daiKeys, err := mappings.StorageRepository.GetDaiKeys()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
for _, d := range daiKeys {
|
||||
mappings.mappings[getDaiKey(d)] = getDaiMetadata(d)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (mappings *VatMappings) loadGemKeys() error {
|
||||
gemKeys, err := mappings.StorageRepository.GetGemKeys()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
for _, gem := range gemKeys {
|
||||
mappings.mappings[getGemKey(gem.Ilk, gem.Guy)] = getGemMetadata(gem.Ilk, gem.Guy)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (mappings *VatMappings) loadIlkKeys() error {
|
||||
ilks, err := mappings.StorageRepository.GetIlks()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
for _, ilk := range ilks {
|
||||
mappings.mappings[getIlkTakeKey(ilk)] = getIlkTakeMetadata(ilk)
|
||||
mappings.mappings[getIlkRateKey(ilk)] = getIlkRateMetadata(ilk)
|
||||
mappings.mappings[getIlkInkKey(ilk)] = getIlkInkMetadata(ilk)
|
||||
mappings.mappings[getIlkArtKey(ilk)] = getIlkArtMetadata(ilk)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (mappings *VatMappings) loadSinKeys() error {
|
||||
sinKeys, err := mappings.StorageRepository.GetSinKeys()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
for _, s := range sinKeys {
|
||||
mappings.mappings[getSinKey(s)] = getSinMetadata(s)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (mappings *VatMappings) loadUrnKeys() error {
|
||||
urns, err := mappings.StorageRepository.GetUrns()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
for _, urn := range urns {
|
||||
mappings.mappings[getUrnInkKey(urn.Ilk, urn.Guy)] = getUrnInkMetadata(urn.Ilk, urn.Guy)
|
||||
mappings.mappings[getUrnArtKey(urn.Ilk, urn.Guy)] = getUrnArtMetadata(urn.Ilk, urn.Guy)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func getIlkTakeKey(ilk string) common.Hash {
|
||||
return storage_diffs.GetMapping(IlksMappingIndex, ilk)
|
||||
}
|
||||
|
||||
func getIlkTakeMetadata(ilk string) shared.StorageValueMetadata {
|
||||
keys := map[shared.Key]string{shared.Ilk: ilk}
|
||||
return shared.GetStorageValueMetadata(IlkTake, keys, shared.Uint256)
|
||||
}
|
||||
|
||||
func getIlkRateKey(ilk string) common.Hash {
|
||||
return storage_diffs.GetIncrementedKey(getIlkTakeKey(ilk), 1)
|
||||
}
|
||||
|
||||
func getIlkRateMetadata(ilk string) shared.StorageValueMetadata {
|
||||
keys := map[shared.Key]string{shared.Ilk: ilk}
|
||||
return shared.GetStorageValueMetadata(IlkRate, keys, shared.Uint256)
|
||||
}
|
||||
|
||||
func getIlkInkKey(ilk string) common.Hash {
|
||||
return storage_diffs.GetIncrementedKey(getIlkTakeKey(ilk), 2)
|
||||
}
|
||||
|
||||
func getIlkInkMetadata(ilk string) shared.StorageValueMetadata {
|
||||
keys := map[shared.Key]string{shared.Ilk: ilk}
|
||||
return shared.GetStorageValueMetadata(IlkInk, keys, shared.Uint256)
|
||||
}
|
||||
|
||||
func getIlkArtKey(ilk string) common.Hash {
|
||||
return storage_diffs.GetIncrementedKey(getIlkTakeKey(ilk), 3)
|
||||
}
|
||||
|
||||
func getIlkArtMetadata(ilk string) shared.StorageValueMetadata {
|
||||
keys := map[shared.Key]string{shared.Ilk: ilk}
|
||||
return shared.GetStorageValueMetadata(IlkArt, keys, shared.Uint256)
|
||||
}
|
||||
|
||||
func getUrnInkKey(ilk, guy string) common.Hash {
|
||||
return storage_diffs.GetNestedMapping(UrnsMappingIndex, ilk, guy)
|
||||
}
|
||||
|
||||
func getUrnInkMetadata(ilk, guy string) shared.StorageValueMetadata {
|
||||
keys := map[shared.Key]string{shared.Ilk: ilk, shared.Guy: guy}
|
||||
return shared.GetStorageValueMetadata(UrnInk, keys, shared.Uint256)
|
||||
}
|
||||
|
||||
func getUrnArtKey(ilk, guy string) common.Hash {
|
||||
return storage_diffs.GetIncrementedKey(getUrnInkKey(ilk, guy), 1)
|
||||
}
|
||||
|
||||
func getUrnArtMetadata(ilk, guy string) shared.StorageValueMetadata {
|
||||
keys := map[shared.Key]string{shared.Ilk: ilk, shared.Guy: guy}
|
||||
return shared.GetStorageValueMetadata(UrnArt, keys, shared.Uint256)
|
||||
}
|
||||
|
||||
func getGemKey(ilk, guy string) common.Hash {
|
||||
return storage_diffs.GetNestedMapping(GemsMappingIndex, ilk, guy)
|
||||
}
|
||||
|
||||
func getGemMetadata(ilk, guy string) shared.StorageValueMetadata {
|
||||
keys := map[shared.Key]string{shared.Ilk: ilk, shared.Guy: guy}
|
||||
return shared.GetStorageValueMetadata(Gem, keys, shared.Uint256)
|
||||
}
|
||||
|
||||
func getDaiKey(guy string) common.Hash {
|
||||
return storage_diffs.GetMapping(DaiMappingIndex, guy)
|
||||
}
|
||||
|
||||
func getDaiMetadata(guy string) shared.StorageValueMetadata {
|
||||
keys := map[shared.Key]string{shared.Guy: guy}
|
||||
return shared.GetStorageValueMetadata(Dai, keys, shared.Uint256)
|
||||
}
|
||||
|
||||
func getSinKey(guy string) common.Hash {
|
||||
return storage_diffs.GetMapping(SinMappingIndex, guy)
|
||||
}
|
||||
|
||||
func getSinMetadata(guy string) shared.StorageValueMetadata {
|
||||
keys := map[shared.Key]string{shared.Guy: guy}
|
||||
return shared.GetStorageValueMetadata(Sin, keys, shared.Uint256)
|
||||
}
|
||||
@@ -1,233 +0,0 @@
|
||||
package vat_test
|
||||
|
||||
import (
|
||||
"github.com/ethereum/go-ethereum/common"
|
||||
"github.com/ethereum/go-ethereum/crypto"
|
||||
. "github.com/onsi/ginkgo"
|
||||
. "github.com/onsi/gomega"
|
||||
"github.com/vulcanize/vulcanizedb/pkg/fakes"
|
||||
"github.com/vulcanize/vulcanizedb/pkg/transformers/storage_diffs/maker"
|
||||
"github.com/vulcanize/vulcanizedb/pkg/transformers/storage_diffs/maker/test_helpers"
|
||||
"github.com/vulcanize/vulcanizedb/pkg/transformers/storage_diffs/maker/vat"
|
||||
"github.com/vulcanize/vulcanizedb/pkg/transformers/storage_diffs/shared"
|
||||
"math/big"
|
||||
)
|
||||
|
||||
var _ = Describe("Vat storage mappings", func() {
|
||||
var (
|
||||
fakeIlk = "fakeIlk"
|
||||
fakeGuy = "fakeGuy"
|
||||
storageRepository *test_helpers.MockMakerStorageRepository
|
||||
mappings vat.VatMappings
|
||||
)
|
||||
|
||||
BeforeEach(func() {
|
||||
storageRepository = &test_helpers.MockMakerStorageRepository{}
|
||||
mappings = vat.VatMappings{StorageRepository: storageRepository}
|
||||
})
|
||||
|
||||
Describe("looking up static keys", func() {
|
||||
It("returns value metadata if key exists", func() {
|
||||
Expect(mappings.Lookup(vat.DebtKey)).To(Equal(vat.DebtMetadata))
|
||||
Expect(mappings.Lookup(vat.ViceKey)).To(Equal(vat.ViceMetadata))
|
||||
})
|
||||
|
||||
It("returns error if key does not exist", func() {
|
||||
_, err := mappings.Lookup(common.HexToHash(fakes.FakeHash.Hex()))
|
||||
|
||||
Expect(err).To(HaveOccurred())
|
||||
Expect(err).To(MatchError(shared.ErrStorageKeyNotFound{Key: fakes.FakeHash.Hex()}))
|
||||
})
|
||||
})
|
||||
|
||||
Describe("looking up dynamic keys", func() {
|
||||
It("refreshes mappings from repository if key not found", func() {
|
||||
mappings.Lookup(fakes.FakeHash)
|
||||
|
||||
Expect(storageRepository.GetDaiKeysCalled).To(BeTrue())
|
||||
Expect(storageRepository.GetGemKeysCalled).To(BeTrue())
|
||||
Expect(storageRepository.GetIlksCalled).To(BeTrue())
|
||||
Expect(storageRepository.GetSinKeysCalled).To(BeTrue())
|
||||
Expect(storageRepository.GetUrnsCalled).To(BeTrue())
|
||||
})
|
||||
|
||||
It("returns error if dai keys lookup fails", func() {
|
||||
storageRepository.GetDaiKeysError = fakes.FakeError
|
||||
|
||||
_, err := mappings.Lookup(fakes.FakeHash)
|
||||
|
||||
Expect(err).To(HaveOccurred())
|
||||
Expect(err).To(MatchError(fakes.FakeError))
|
||||
})
|
||||
|
||||
It("returns error if gem keys lookup fails", func() {
|
||||
storageRepository.GetGemKeysError = fakes.FakeError
|
||||
|
||||
_, err := mappings.Lookup(fakes.FakeHash)
|
||||
|
||||
Expect(err).To(HaveOccurred())
|
||||
Expect(err).To(MatchError(fakes.FakeError))
|
||||
})
|
||||
|
||||
It("returns error if ilks lookup fails", func() {
|
||||
storageRepository.GetIlksError = fakes.FakeError
|
||||
|
||||
_, err := mappings.Lookup(fakes.FakeHash)
|
||||
|
||||
Expect(err).To(HaveOccurred())
|
||||
Expect(err).To(MatchError(fakes.FakeError))
|
||||
})
|
||||
|
||||
It("returns error if sin keys lookup fails", func() {
|
||||
storageRepository.GetSinKeysError = fakes.FakeError
|
||||
|
||||
_, err := mappings.Lookup(fakes.FakeHash)
|
||||
|
||||
Expect(err).To(HaveOccurred())
|
||||
Expect(err).To(MatchError(fakes.FakeError))
|
||||
})
|
||||
|
||||
It("returns error if urns lookup fails", func() {
|
||||
storageRepository.GetUrnsError = fakes.FakeError
|
||||
|
||||
_, err := mappings.Lookup(fakes.FakeHash)
|
||||
|
||||
Expect(err).To(HaveOccurred())
|
||||
Expect(err).To(MatchError(fakes.FakeError))
|
||||
})
|
||||
|
||||
Describe("ilk", func() {
|
||||
It("returns value metadata for ilk take", func() {
|
||||
storageRepository.Ilks = []string{fakeIlk}
|
||||
ilkTakeKey := common.BytesToHash(crypto.Keccak256(common.FromHex("0x" + fakeIlk + vat.IlksMappingIndex)))
|
||||
expectedMetadata := shared.StorageValueMetadata{
|
||||
Name: vat.IlkTake,
|
||||
Keys: map[shared.Key]string{shared.Ilk: fakeIlk},
|
||||
Type: shared.Uint256,
|
||||
}
|
||||
|
||||
Expect(mappings.Lookup(ilkTakeKey)).To(Equal(expectedMetadata))
|
||||
})
|
||||
|
||||
It("returns value metadata for ilk rate", func() {
|
||||
storageRepository.Ilks = []string{fakeIlk}
|
||||
ilkTakeBytes := crypto.Keccak256(common.FromHex("0x" + fakeIlk + vat.IlksMappingIndex))
|
||||
ilkTakeAsInt := big.NewInt(0).SetBytes(ilkTakeBytes)
|
||||
incrementedIlkTake := big.NewInt(0).Add(ilkTakeAsInt, big.NewInt(1))
|
||||
ilkRateKey := common.BytesToHash(incrementedIlkTake.Bytes())
|
||||
expectedMetadata := shared.StorageValueMetadata{
|
||||
Name: vat.IlkRate,
|
||||
Keys: map[shared.Key]string{shared.Ilk: fakeIlk},
|
||||
Type: shared.Uint256,
|
||||
}
|
||||
|
||||
Expect(mappings.Lookup(ilkRateKey)).To(Equal(expectedMetadata))
|
||||
})
|
||||
|
||||
It("returns value metadata for ilk Ink", func() {
|
||||
storageRepository.Ilks = []string{fakeIlk}
|
||||
ilkTakeBytes := crypto.Keccak256(common.FromHex("0x" + fakeIlk + vat.IlksMappingIndex))
|
||||
ilkTakeAsInt := big.NewInt(0).SetBytes(ilkTakeBytes)
|
||||
doubleIncrementedIlkTake := big.NewInt(0).Add(ilkTakeAsInt, big.NewInt(2))
|
||||
ilkInkKey := common.BytesToHash(doubleIncrementedIlkTake.Bytes())
|
||||
expectedMetadata := shared.StorageValueMetadata{
|
||||
Name: vat.IlkInk,
|
||||
Keys: map[shared.Key]string{shared.Ilk: fakeIlk},
|
||||
Type: shared.Uint256,
|
||||
}
|
||||
|
||||
Expect(mappings.Lookup(ilkInkKey)).To(Equal(expectedMetadata))
|
||||
})
|
||||
|
||||
It("returns value metadata for ilk Art", func() {
|
||||
storageRepository.Ilks = []string{fakeIlk}
|
||||
ilkTakeBytes := crypto.Keccak256(common.FromHex("0x" + fakeIlk + vat.IlksMappingIndex))
|
||||
ilkTakeAsInt := big.NewInt(0).SetBytes(ilkTakeBytes)
|
||||
tripleIncrementedIlkTake := big.NewInt(0).Add(ilkTakeAsInt, big.NewInt(3))
|
||||
ilkArtKey := common.BytesToHash(tripleIncrementedIlkTake.Bytes())
|
||||
expectedMetadata := shared.StorageValueMetadata{
|
||||
Name: vat.IlkArt,
|
||||
Keys: map[shared.Key]string{shared.Ilk: fakeIlk},
|
||||
Type: shared.Uint256,
|
||||
}
|
||||
|
||||
Expect(mappings.Lookup(ilkArtKey)).To(Equal(expectedMetadata))
|
||||
})
|
||||
})
|
||||
|
||||
Describe("urn", func() {
|
||||
It("returns value metadata for urn ink", func() {
|
||||
storageRepository.Urns = []maker.Urn{{Ilk: fakeIlk, Guy: fakeGuy}}
|
||||
encodedPrimaryMapIndex := crypto.Keccak256(common.FromHex("0x" + fakeIlk + vat.UrnsMappingIndex))
|
||||
encodedSecondaryMapIndex := crypto.Keccak256(common.FromHex(fakeGuy), encodedPrimaryMapIndex)
|
||||
urnInkKey := common.BytesToHash(encodedSecondaryMapIndex)
|
||||
expectedMetadata := shared.StorageValueMetadata{
|
||||
Name: vat.UrnInk,
|
||||
Keys: map[shared.Key]string{shared.Ilk: fakeIlk, shared.Guy: fakeGuy},
|
||||
Type: shared.Uint256,
|
||||
}
|
||||
|
||||
Expect(mappings.Lookup(urnInkKey)).To(Equal(expectedMetadata))
|
||||
})
|
||||
|
||||
It("returns value metadata for urn art", func() {
|
||||
storageRepository.Urns = []maker.Urn{{Ilk: fakeIlk, Guy: fakeGuy}}
|
||||
encodedPrimaryMapIndex := crypto.Keccak256(common.FromHex("0x" + fakeIlk + vat.UrnsMappingIndex))
|
||||
urnInkAsInt := big.NewInt(0).SetBytes(crypto.Keccak256(common.FromHex(fakeGuy), encodedPrimaryMapIndex))
|
||||
incrementedUrnInk := big.NewInt(0).Add(urnInkAsInt, big.NewInt(1))
|
||||
urnArtKey := common.BytesToHash(incrementedUrnInk.Bytes())
|
||||
expectedMetadata := shared.StorageValueMetadata{
|
||||
Name: vat.UrnArt,
|
||||
Keys: map[shared.Key]string{shared.Ilk: fakeIlk, shared.Guy: fakeGuy},
|
||||
Type: shared.Uint256,
|
||||
}
|
||||
|
||||
Expect(mappings.Lookup(urnArtKey)).To(Equal(expectedMetadata))
|
||||
})
|
||||
})
|
||||
|
||||
Describe("gem", func() {
|
||||
It("returns value metadata for gem", func() {
|
||||
storageRepository.GemKeys = []maker.Urn{{Ilk: fakeIlk, Guy: fakeGuy}}
|
||||
encodedPrimaryMapIndex := crypto.Keccak256(common.FromHex("0x" + fakeIlk + vat.GemsMappingIndex))
|
||||
encodedSecondaryMapIndex := crypto.Keccak256(common.FromHex(fakeGuy), encodedPrimaryMapIndex)
|
||||
gemKey := common.BytesToHash(encodedSecondaryMapIndex)
|
||||
expectedMetadata := shared.StorageValueMetadata{
|
||||
Name: vat.Gem,
|
||||
Keys: map[shared.Key]string{shared.Ilk: fakeIlk, shared.Guy: fakeGuy},
|
||||
Type: shared.Uint256,
|
||||
}
|
||||
|
||||
Expect(mappings.Lookup(gemKey)).To(Equal(expectedMetadata))
|
||||
})
|
||||
})
|
||||
|
||||
Describe("dai", func() {
|
||||
It("returns value metadata for dai", func() {
|
||||
storageRepository.DaiKeys = []string{fakeGuy}
|
||||
daiKey := common.BytesToHash(crypto.Keccak256(common.FromHex("0x" + fakeGuy + vat.DaiMappingIndex)))
|
||||
expectedMetadata := shared.StorageValueMetadata{
|
||||
Name: vat.Dai,
|
||||
Keys: map[shared.Key]string{shared.Guy: fakeGuy},
|
||||
Type: shared.Uint256,
|
||||
}
|
||||
|
||||
Expect(mappings.Lookup(daiKey)).To(Equal(expectedMetadata))
|
||||
})
|
||||
})
|
||||
|
||||
Describe("when sin key exists in the db", func() {
|
||||
It("returns value metadata for sin", func() {
|
||||
storageRepository.SinKeys = []string{fakeGuy}
|
||||
sinKey := common.BytesToHash(crypto.Keccak256(common.FromHex("0x" + fakeGuy + vat.SinMappingIndex)))
|
||||
expectedMetadata := shared.StorageValueMetadata{
|
||||
Name: vat.Sin,
|
||||
Keys: map[shared.Key]string{shared.Guy: fakeGuy},
|
||||
Type: shared.Uint256,
|
||||
}
|
||||
|
||||
Expect(mappings.Lookup(sinKey)).To(Equal(expectedMetadata))
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
Reference in New Issue
Block a user