Update address formatting (#67)

* Add getSignatures command for list of signatures in constants

* Update VatTune converter's formatting of addresses

and added an integration test

* Move VatTune and PriceFeeds integration tests to a common suite

* Update VatGrab converter for address format

* Update frob converter to fix urn and ilk formatting/decoding

* Update formatting

* Update make test command and add integrationtest command

* Add integration test to travis build

* Update creating headers in integration tests to include Raw and Timestamp fields
This commit is contained in:
Elizabeth 2018-10-17 13:04:55 -05:00 committed by GitHub
parent 75246e9ce9
commit 3baca64903
17 changed files with 373 additions and 113 deletions

View File

@ -31,6 +31,7 @@ script:
- yarn test
- cd ../
- make test
- make integrationtest
notifications:
email: false

View File

@ -44,7 +44,13 @@ lint:
test: | $(GINKGO) $(LINT)
go vet ./...
go fmt ./...
$(GINKGO) -r
$(GINKGO) -r --skipPackage=integration_tests
.PHONY: integrationtest
integrationtest: | $(GINKGO) $(LINT)
go vet ./...
go fmt ./...
$(GINKGO) -r --flakeAttempts=5 pkg/transformers/integration_tests/
.PHONY: dep
dep: | $(DEP)

View File

@ -130,7 +130,8 @@ false
If you have full rinkeby chaindata you can move it to `rinkeby_vulcanizedb_geth_data` docker volume to skip long wait of sync.
## Running the Tests
- `make test`
- `make test` will run the unit tests and skip the integration tests
- `make integrationtest` will run the just the integration tests
- Note: requires Ganache chain setup and seeded with `flip-kick.js` and `frob.js` (in that order)
## Deploying

63
cmd/getSignatures.go Normal file
View File

@ -0,0 +1,63 @@
// Copyright © 2018 NAME HERE <EMAIL ADDRESS>
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package cmd
import (
"github.com/spf13/cobra"
"github.com/vulcanize/vulcanizedb/pkg/transformers/shared"
"log"
)
// getSignaturesCmd represents the getSignatures command
var getSignaturesCmd = &cobra.Command{
Use: "getSignatures",
Short: "A command to see transformer method and event signatures",
Long: `A convenience command to see method/event signatures for Maker transformers
vulcanizedb getSignatures`,
Run: func(cmd *cobra.Command, args []string) {},
}
func init() {
rootCmd.AddCommand(getSignaturesCmd)
signatures := make(map[string]string)
signatures["BiteSignature"] = shared.BiteSignature
signatures["DealSignature"] = shared.DealSignature
signatures["CatFileChopLumpSignature"] = shared.CatFileChopLumpSignature
signatures["CatFileFlipSignature"] = shared.CatFileFlipSignature
signatures["CatFilePitVowSignature"] = shared.CatFilePitVowSignature
signatures["DentFunctionSignature"] = shared.DentFunctionSignature
signatures["DripDripSignature"] = shared.DripDripSignature
signatures["DripFileIlkSignature"] = shared.DripFileIlkSignature
signatures["DripFileRepoSignature"] = shared.DripFileRepoSignature
signatures["DripFileVowSignature"] = shared.DripFileVowSignature
signatures["FlipKickSignature"] = shared.FlipKickSignature
signatures["FlopKickSignature"] = shared.FlopKickSignature
signatures["FrobSignature"] = shared.FrobSignature
signatures["LogValueSignature"] = shared.LogValueSignature
signatures["PitFileDebtCeilingSignature"] = shared.PitFileDebtCeilingSignature
signatures["PitFileIlkSignature"] = shared.PitFileIlkSignature
signatures["PitFileStabilityFeeSignature"] = shared.PitFileStabilityFeeSignature
signatures["TendFunctionSignature"] = shared.TendFunctionSignature
signatures["VatHealSignature"] = shared.VatHealSignature
signatures["VatGrabSignature"] = shared.VatGrabSignature
signatures["VatInitSignature"] = shared.VatInitSignature
signatures["VatFoldSignature"] = shared.VatFoldSignature
signatures["VatTollSignature"] = shared.VatTollSignature
signatures["VatTuneSignature"] = shared.VatTuneSignature
for name, sig := range signatures {
log.Println(name, ": ", sig)
}
}

View File

@ -18,6 +18,7 @@ import (
"github.com/ethereum/go-ethereum/accounts/abi/bind"
"github.com/ethereum/go-ethereum/core/types"
"bytes"
"encoding/json"
"github.com/ethereum/go-ethereum/common"
"github.com/vulcanize/vulcanizedb/pkg/geth"
@ -57,8 +58,8 @@ func (FrobConverter) ToModels(entities []FrobEntity) ([]FrobModel, error) {
return nil, err
}
model := FrobModel{
Ilk: common.BytesToAddress(entity.Ilk[:common.AddressLength]).String(),
Urn: common.BytesToAddress(entity.Urn[:common.AddressLength]).String(),
Ilk: string(bytes.Trim(entity.Ilk[:], "\x00)")),
Urn: common.BytesToAddress(entity.Urn[:]).String(),
Ink: entity.Ink.String(),
Art: entity.Art.String(),
Dink: entity.Dink.String(),

View File

@ -12,52 +12,57 @@
// See the License for the specific language governing permissions and
// limitations under the License.
package frob_test
package integration_tests
import (
"github.com/ethereum/go-ethereum/accounts/abi/bind"
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/ethclient"
"github.com/ethereum/go-ethereum/rpc"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"github.com/vulcanize/vulcanizedb/pkg/geth"
"github.com/vulcanize/vulcanizedb/pkg/geth/client"
vRpc "github.com/vulcanize/vulcanizedb/pkg/geth/converters/rpc"
"github.com/vulcanize/vulcanizedb/pkg/geth/node"
"github.com/vulcanize/vulcanizedb/pkg/transformers/frob"
"github.com/vulcanize/vulcanizedb/pkg/transformers/shared"
"github.com/vulcanize/vulcanizedb/pkg/transformers/test_data"
"github.com/vulcanize/vulcanizedb/test_config"
)
var _ = Describe("Integration tests", func() {
XIt("Fetches frob event logs from a local test chain", func() {
ipcPath := test_config.TestClient.IPCPath
var _ = Describe("Frob Transformer", func() {
It("fetches and transforms a Frob event from Kovan chain", func() {
blockNumber := int64(8935258)
config := frob.FrobConfig
config.StartingBlockNumber = blockNumber
config.EndingBlockNumber = blockNumber
rawRpcClient, err := rpc.Dial(ipcPath)
ipc := "https://kovan.infura.io/J5Vd2fRtGsw0zZ0Ov3BL"
rpcClient, ethClient, err := getClients(ipc)
Expect(err).NotTo(HaveOccurred())
blockchain, err := getBlockChain(rpcClient, ethClient)
Expect(err).NotTo(HaveOccurred())
rpcClient := client.NewRpcClient(rawRpcClient, ipcPath)
ethClient := ethclient.NewClient(rawRpcClient)
blockChainClient := client.NewEthClient(ethClient)
realNode := node.MakeNode(rpcClient)
transactionConverter := vRpc.NewRpcTransactionConverter(ethClient)
realBlockChain := geth.NewBlockChain(blockChainClient, rpcClient, realNode, transactionConverter)
realFetcher := shared.NewFetcher(realBlockChain)
topic0 := common.HexToHash(shared.FrobSignature)
topics := [][]common.Hash{{topic0}}
db := test_config.NewTestDB(blockchain.Node())
test_config.CleanTestDB(db)
result, err := realFetcher.FetchLogs(frob.FrobConfig.ContractAddresses, topics, int64(12))
err = persistHeader(rpcClient, db, blockNumber)
Expect(err).NotTo(HaveOccurred())
Expect(len(result) > 0).To(BeTrue())
Expect(result[0].Address).To(Equal(common.HexToAddress(shared.PitContractAddress)))
Expect(result[0].TxHash).To(Equal(test_data.EthFrobLog.TxHash))
Expect(result[0].BlockNumber).To(Equal(test_data.EthFrobLog.BlockNumber))
Expect(result[0].Topics).To(Equal(test_data.EthFrobLog.Topics))
Expect(result[0].Index).To(Equal(test_data.EthFrobLog.Index))
initializer := frob.FrobTransformerInitializer{Config: config}
transformer := initializer.NewFrobTransformer(db, blockchain)
err = transformer.Execute()
Expect(err).NotTo(HaveOccurred())
var dbResult []frob.FrobModel
err = db.Select(&dbResult, `SELECT art, dart, dink, iart, ilk, ink, urn from maker.frob`)
Expect(err).NotTo(HaveOccurred())
Expect(len(dbResult)).To(Equal(1))
Expect(dbResult[0].Art).To(Equal("10000000000000000"))
Expect(dbResult[0].Dart).To(Equal("0"))
Expect(dbResult[0].Dink).To(Equal("10000000000000"))
Expect(dbResult[0].IArt).To(Equal("1495509999999999999992"))
Expect(dbResult[0].Ilk).To(Equal("ETH"))
Expect(dbResult[0].Ink).To(Equal("10050100000000000"))
Expect(dbResult[0].Urn).To(Equal("0xc8E093e5f3F9B5Aa6A6b33ea45960b93C161430C"))
})
It("unpacks an event log", func() {

View File

@ -0,0 +1,67 @@
// Copyright 2018 Vulcanize
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package integration_tests
import (
"context"
"encoding/json"
"github.com/ethereum/go-ethereum/common/hexutil"
"github.com/ethereum/go-ethereum/ethclient"
"github.com/ethereum/go-ethereum/rpc"
"github.com/vulcanize/vulcanizedb/pkg/core"
"github.com/vulcanize/vulcanizedb/pkg/datastore/postgres"
"github.com/vulcanize/vulcanizedb/pkg/datastore/postgres/repositories"
"github.com/vulcanize/vulcanizedb/pkg/geth"
"github.com/vulcanize/vulcanizedb/pkg/geth/client"
rpc2 "github.com/vulcanize/vulcanizedb/pkg/geth/converters/rpc"
"github.com/vulcanize/vulcanizedb/pkg/geth/node"
"math/big"
)
func getClients(ipc string) (client.RpcClient, *ethclient.Client, error) {
raw, err := rpc.Dial(ipc)
if err != nil {
return client.RpcClient{}, &ethclient.Client{}, err
}
return client.NewRpcClient(raw, ipc), ethclient.NewClient(raw), nil
}
func getBlockChain(rpcClient client.RpcClient, ethClient *ethclient.Client) (core.BlockChain, error) {
client := client.NewEthClient(ethClient)
node := node.MakeNode(rpcClient)
transactionConverter := rpc2.NewRpcTransactionConverter(client)
blockChain := geth.NewBlockChain(client, rpcClient, node, transactionConverter)
return blockChain, nil
}
func persistHeader(rpcClient client.RpcClient, db *postgres.DB, blockNumber int64) error {
var poaHeader core.POAHeader
blockNumberArg := hexutil.EncodeBig(big.NewInt(int64(blockNumber)))
err := rpcClient.CallContext(context.Background(), &poaHeader, "eth_getBlockByNumber", blockNumberArg, false)
if err != nil {
return err
}
rawHeader, err := json.Marshal(poaHeader)
if err != nil {
return err
}
headerRepository := repositories.NewHeaderRepository(db)
_, err = headerRepository.CreateOrUpdateHeader(core.Header{
BlockNumber: poaHeader.Number.ToInt().Int64(),
Hash: poaHeader.Hash.String(),
Raw: rawHeader,
Timestamp: poaHeader.Time.ToInt().String(),
})
return err
}

View File

@ -0,0 +1,13 @@
package integration_tests
import (
"testing"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)
func TestIntegrationTests(t *testing.T) {
RegisterFailHandler(Fail)
RunSpecs(t, "IntegrationTests Suite")
}

View File

@ -1,24 +1,27 @@
package price_feeds_test
// Copyright 2018 Vulcanize
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package integration_tests
import (
"context"
"encoding/json"
"math/big"
"time"
"github.com/ethereum/go-ethereum/common/hexutil"
"github.com/ethereum/go-ethereum/ethclient"
"github.com/ethereum/go-ethereum/rpc"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"github.com/vulcanize/vulcanizedb/pkg/core"
"github.com/vulcanize/vulcanizedb/pkg/datastore/postgres"
"github.com/vulcanize/vulcanizedb/pkg/datastore/postgres/repositories"
"github.com/vulcanize/vulcanizedb/pkg/geth"
"github.com/vulcanize/vulcanizedb/pkg/geth/client"
rpc2 "github.com/vulcanize/vulcanizedb/pkg/geth/converters/rpc"
"github.com/vulcanize/vulcanizedb/pkg/geth/node"
"github.com/vulcanize/vulcanizedb/pkg/transformers/price_feeds"
"github.com/vulcanize/vulcanizedb/test_config"
)
@ -107,40 +110,3 @@ var _ = Describe("Price feeds transformer", func() {
})
})
})
func getClients(ipc string) (client.RpcClient, *ethclient.Client, error) {
raw, err := rpc.Dial(ipc)
if err != nil {
return client.RpcClient{}, &ethclient.Client{}, err
}
return client.NewRpcClient(raw, ipc), ethclient.NewClient(raw), nil
}
func getBlockChain(rpcClient client.RpcClient, ethClient *ethclient.Client) (core.BlockChain, error) {
client := client.NewEthClient(ethClient)
node := node.MakeNode(rpcClient)
transactionConverter := rpc2.NewRpcTransactionConverter(client)
blockChain := geth.NewBlockChain(client, rpcClient, node, transactionConverter)
return blockChain, nil
}
func persistHeader(rpcClient client.RpcClient, db *postgres.DB, blockNumber int64) error {
var poaHeader core.POAHeader
blockNumberArg := hexutil.EncodeBig(big.NewInt(int64(blockNumber)))
err := rpcClient.CallContext(context.Background(), &poaHeader, "eth_getBlockByNumber", blockNumberArg, false)
if err != nil {
return err
}
rawHeader, err := json.Marshal(poaHeader)
if err != nil {
return err
}
headerRepository := repositories.NewHeaderRepository(db)
_, err = headerRepository.CreateOrUpdateHeader(core.Header{
BlockNumber: poaHeader.Number.ToInt().Int64(),
Hash: poaHeader.Hash.String(),
Raw: rawHeader,
Timestamp: poaHeader.Time.ToInt().String(),
})
return err
}

View File

@ -0,0 +1,68 @@
// Copyright 2018 Vulcanize
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package integration_tests
import (
"math/big"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"github.com/vulcanize/vulcanizedb/pkg/transformers/vat_grab"
"github.com/vulcanize/vulcanizedb/test_config"
)
var _ = Describe("Vat Grab Transformer", func() {
It("transforms VatGrab log events", func() {
blockNumber := int64(8958230)
config := vat_grab.VatGrabConfig
config.StartingBlockNumber = blockNumber
config.EndingBlockNumber = blockNumber
ipc := "https://kovan.infura.io/J5Vd2fRtGsw0zZ0Ov3BL"
rpcClient, ethClient, err := getClients(ipc)
Expect(err).NotTo(HaveOccurred())
blockchain, err := getBlockChain(rpcClient, ethClient)
Expect(err).NotTo(HaveOccurred())
db := test_config.NewTestDB(blockchain.Node())
test_config.CleanTestDB(db)
err = persistHeader(rpcClient, db, blockNumber)
Expect(err).NotTo(HaveOccurred())
initializer := vat_grab.VatGrabTransformerInitializer{Config: config}
transformer := initializer.NewVatGrabTransformer(db, blockchain)
err = transformer.Execute()
Expect(err).NotTo(HaveOccurred())
var dbResult []vat_grab.VatGrabModel
err = db.Select(&dbResult, `SELECT ilk, urn, v, w, dink, dart from maker.vat_grab`)
Expect(err).NotTo(HaveOccurred())
Expect(len(dbResult)).To(Equal(1))
Expect(dbResult[0].Ilk).To(Equal("REP"))
Expect(dbResult[0].Urn).To(Equal("0x6a3AE20C315E845B2E398e68EfFe39139eC6060C"))
Expect(dbResult[0].V).To(Equal("0x2F34f22a00eE4b7a8F8BBC4eAee1658774c624e0")) //cat contract address
Expect(dbResult[0].W).To(Equal("0x3728e9777B2a0a611ee0F89e00E01044ce4736d1"))
expectedDink := new(big.Int)
expectedDink.SetString("115792089237316195423570985008687907853269984665640564039455584007913129639936", 10)
Expect(dbResult[0].Dink).To(Equal(expectedDink.String()))
expectedDart := new(big.Int)
expectedDart.SetString("115792089237316195423570985008687907853269984665640564039441803007913129639936", 10)
Expect(dbResult[0].Dart).To(Equal(expectedDart.String()))
Expect(dbResult[0].TransactionIndex).To(Equal(uint(0)))
})
})

View File

@ -0,0 +1,66 @@
// Copyright 2018 Vulcanize
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package integration_tests
import (
"math/big"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"github.com/vulcanize/vulcanizedb/pkg/transformers/vat_tune"
"github.com/vulcanize/vulcanizedb/test_config"
)
var _ = Describe("VatTune Transformer", func() {
It("transforms VatTune log events", func() {
blockNumber := int64(8761670)
config := vat_tune.VatTuneConfig
config.StartingBlockNumber = blockNumber
config.EndingBlockNumber = blockNumber
ipc := "https://kovan.infura.io/J5Vd2fRtGsw0zZ0Ov3BL"
rpcClient, ethClient, err := getClients(ipc)
Expect(err).NotTo(HaveOccurred())
blockchain, err := getBlockChain(rpcClient, ethClient)
Expect(err).NotTo(HaveOccurred())
db := test_config.NewTestDB(blockchain.Node())
test_config.CleanTestDB(db)
err = persistHeader(rpcClient, db, blockNumber)
Expect(err).NotTo(HaveOccurred())
initializer := vat_tune.VatTuneTransformerInitializer{Config: config}
transformer := initializer.NewVatTuneTransformer(db, blockchain)
err = transformer.Execute()
Expect(err).NotTo(HaveOccurred())
var dbResult []vat_tune.VatTuneModel
err = db.Select(&dbResult, `SELECT ilk, urn, v, w, dink, dart from maker.vat_tune`)
Expect(err).NotTo(HaveOccurred())
Expect(len(dbResult)).To(Equal(1))
Expect(dbResult[0].Ilk).To(Equal("ETH"))
Expect(dbResult[0].Urn).To(Equal("0x4F26FfBe5F04ED43630fdC30A87638d53D0b0876"))
Expect(dbResult[0].V).To(Equal("0x4F26FfBe5F04ED43630fdC30A87638d53D0b0876"))
Expect(dbResult[0].W).To(Equal("0x4F26FfBe5F04ED43630fdC30A87638d53D0b0876"))
Expect(dbResult[0].Dink).To(Equal("0"))
expectedDart := new(big.Int)
expectedDart.SetString("115792089237316195423570985008687907853269984665640564039455584007913129639936", 10)
Expect(dbResult[0].Dart).To(Equal(expectedDart.String()))
Expect(dbResult[0].TransactionIndex).To(Equal(uint(0)))
})
})

View File

@ -41,8 +41,8 @@ var (
gem, _ = big.NewInt(0).SetString("115792089237316195423570985008687907853269984665640564039457584007913129639926", 10)
ink = big.NewInt(15)
ilk = [32]byte{102, 97, 107, 101, 32, 105, 108, 107, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
frobIlkString = "0x66616b6520696c6B000000000000000000000000"
frobUrnString = "0x00000000000000000000000064D922894153BE9E"
frobIlkString = "fake ilk"
frobUrnString = "0x64d922894153BE9EEf7b7218dc565d1D0Ce2a092"
)
var EthFrobLog = types.Log{

View File

@ -13,11 +13,11 @@ var EthVatGrabLog = types.Log{
Address: common.HexToAddress(shared.VatContractAddress),
Topics: []common.Hash{
common.HexToHash("0x3690ae4c00000000000000000000000000000000000000000000000000000000"),
common.HexToHash("0x66616b6520696c6b000000000000000000000000000000000000000000000000"),
common.HexToHash("0x07fa9ef6609ca7921112231f8f195138ebba2977000000000000000000000000"),
common.HexToHash("0x7340e006f4135ba6970d43bf43d88dcad4e7a8ca000000000000000000000000"),
common.HexToHash("0x5245500000000000000000000000000000000000000000000000000000000000"),
common.HexToHash("0x0000000000000000000000006a3ae20c315e845b2e398e68effe39139ec6060c"),
common.HexToHash("0x0000000000000000000000002f34f22a00ee4b7a8f8bbc4eaee1658774c624e0"),
},
Data: hexutil.MustDecode("0x000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000c43690ae4c66616b6520696c6b00000000000000000000000000000000000000000000000007fa9ef6609ca7921112231f8f195138ebba29770000000000000000000000007340e006f4135ba6970d43bf43d88dcad4e7a8ca0000000000000000000000007526eb4f95e2a1394797cb38a921fb1eba09291b00000000000000000000000000000000000000000000000000000000000000000000000000000000069f6bc7000000000000000000000000000000000000000000000000000000000d3ed78e"),
Data: hexutil.MustDecode("0x000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000c43690ae4c52455000000000000000000000000000000000000000000000000000000000000000000000000000000000006a3ae20c315e845b2e398e68effe39139ec6060c0000000000000000000000002f34f22a00ee4b7a8f8bbc4eaee1658774c624e00000000000000000000000003728e9777b2a0a611ee0f89e00e01044ce4736d1ffffffffffffffffffffffffffffffffffffffffffffffffe43e9298b1380000ffffffffffffffffffffffffffffffffffffffffffffffff24fea01c7f8f8000"),
BlockNumber: 23,
TxHash: common.HexToHash("0x7cb84c750ce4985f7811abf641d52ffcb35306d943081475226484cf1470c6fa"),
TxIndex: 4,
@ -28,12 +28,12 @@ var EthVatGrabLog = types.Log{
var rawVatGrabLog, _ = json.Marshal(EthVatGrabLog)
var VatGrabModel = vat_grab.VatGrabModel{
Ilk: "fake ilk",
Urn: "0x07Fa9eF6609cA7921112231F8f195138ebbA2977",
V: "0x7340e006f4135BA6970D43bf43d88DCAD4e7a8CA",
W: "0x7526EB4f95e2a1394797Cb38a921Fb1EbA09291B",
Dink: "111111111",
Dart: "222222222",
Ilk: "REP",
Urn: "0x6a3AE20C315E845B2E398e68EfFe39139eC6060C",
V: "0x2F34f22a00eE4b7a8F8BBC4eAee1658774c624e0",
W: "0x3728e9777B2a0a611ee0F89e00E01044ce4736d1",
Dink: "115792089237316195423570985008687907853269984665640564039455584007913129639936",
Dart: "115792089237316195423570985008687907853269984665640564039441803007913129639936",
TransactionIndex: EthVatGrabLog.TxIndex,
Raw: rawVatGrabLog,
}

View File

@ -12,30 +12,33 @@ import (
)
var EthVatTuneLog = types.Log{
Address: common.HexToAddress("0x239E6f0AB02713f1F8AA90ebeDeD9FC66Dc96CD6"),
Address: common.HexToAddress("0xCD726790550aFcd77e9a7a47e86A3F9010af126B"),
Topics: []common.Hash{
common.HexToHash("0x5dd6471a00000000000000000000000000000000000000000000000000000000"),
common.HexToHash("0x66616b6520696c6b000000000000000000000000000000000000000000000000"),
common.HexToHash("0x7d7bee5fcfd8028cf7b00876c5b1421c800561a6000000000000000000000000"),
common.HexToHash("0xa3e37186e017747dba34042e83e3f76ad3cce9b0000000000000000000000000"),
common.HexToHash("0x4554480000000000000000000000000000000000000000000000000000000000"),
common.HexToHash("0x0000000000000000000000004f26ffbe5f04ed43630fdc30a87638d53d0b0876"),
common.HexToHash("0x0000000000000000000000004f26ffbe5f04ed43630fdc30a87638d53d0b0876"),
},
Data: hexutil.MustDecode("0x000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000c45dd6471a66616b6520696c6b0000000000000000000000000000000000000000000000007d7bee5fcfd8028cf7b00876c5b1421c800561a6000000000000000000000000a3e37186e017747dba34042e83e3f76ad3cce9b00000000000000000000000000f243e26db94b5426032e6dfa6007802dea2a61400000000000000000000000000000000000000000000000000000000000000000000000000000000075bcd15000000000000000000000000000000000000000000000000000000003ade68b1"),
BlockNumber: 22,
TxHash: common.HexToHash("0x2b19ef3965420d2d5eb8792eafbd5e365b2866200cfc4473835971f6965f831c"),
TxIndex: 3,
BlockHash: common.HexToHash("0xf3a4a9ecb79a721421b347424dc9fa072ca762f3ba340557b54a205f058f59a6"),
Data: hexutil.MustDecode("0x000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000c45dd6471a45544800000000000000000000000000000000000000000000000000000000000000000000000000000000004f26ffbe5f04ed43630fdc30a87638d53d0b08760000000000000000000000004f26ffbe5f04ed43630fdc30a87638d53d0b08760000000000000000000000004f26ffbe5f04ed43630fdc30a87638d53d0b08760000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffffffffffffffffffffffffffffe43e9298b1380000"),
BlockNumber: 8761670,
TxHash: common.HexToHash("0x95eb3d6cbd83032efa29714d4a391ce163d7d215db668aadd7d33dd5c20b1ec7"),
TxIndex: 0,
BlockHash: common.HexToHash("0xd35188df40a741f4bf4ccacc6be0154e338652660d0b56cc9058c1bca53b09ee"),
Index: 6,
Removed: false,
}
var rawVatTuneLog, _ = json.Marshal(EthVatTuneLog)
var dartString = "115792089237316195423570985008687907853269984665640564039455584007913129639936"
var vatTuneDart, _ = new(big.Int).SetString(dartString, 10)
var urnAddress = "0x4F26FfBe5F04ED43630fdC30A87638d53D0b0876"
var VatTuneModel = vat_tune.VatTuneModel{
Ilk: "fake ilk",
Urn: "0x7d7bEe5fCfD8028cf7b00876C5b1421c800561A6",
V: "0xA3E37186E017747DbA34042e83e3F76Ad3CcE9b0",
W: "0x0F243E26db94B5426032E6DFA6007802Dea2a614",
Dink: big.NewInt(123456789).String(),
Dart: big.NewInt(987654321).String(),
Ilk: "ETH",
Urn: urnAddress,
V: urnAddress,
W: urnAddress,
Dink: big.NewInt(0).String(),
Dart: vatTuneDart.String(),
TransactionIndex: EthVatTuneLog.TxIndex,
Raw: rawVatTuneLog,
}

View File

@ -24,10 +24,10 @@ func (VatGrabConverter) ToModels(ethLogs []types.Log) ([]VatGrabModel, error) {
return nil, err
}
ilk := string(bytes.Trim(ethLog.Topics[1].Bytes(), "\x00"))
urn := common.BytesToAddress(ethLog.Topics[2].Bytes()[:common.AddressLength])
v := common.BytesToAddress(ethLog.Topics[3].Bytes()[:common.AddressLength])
urn := common.BytesToAddress(ethLog.Topics[2].Bytes())
v := common.BytesToAddress(ethLog.Topics[3].Bytes())
wBytes := shared.GetDataBytesAtIndex(-3, ethLog.Data)
w := common.BytesToAddress(wBytes[:common.AddressLength])
w := common.BytesToAddress(wBytes)
dinkBytes := shared.GetDataBytesAtIndex(-2, ethLog.Data)
dink := big.NewInt(0).SetBytes(dinkBytes).String()
dartBytes := shared.GetDataBytesAtIndex(-1, ethLog.Data)

View File

@ -26,10 +26,10 @@ func (VatTuneConverter) ToModels(ethLogs []types.Log) ([]VatTuneModel, error) {
return nil, err
}
ilk := string(bytes.Trim(ethLog.Topics[1].Bytes(), "\x00"))
urn := common.BytesToAddress(ethLog.Topics[2].Bytes()[:common.AddressLength])
v := common.BytesToAddress(ethLog.Topics[3].Bytes()[:common.AddressLength])
urn := common.BytesToAddress(ethLog.Topics[2].Bytes())
v := common.BytesToAddress(ethLog.Topics[3].Bytes())
wBytes := shared.GetDataBytesAtIndex(-3, ethLog.Data)
w := common.BytesToAddress(wBytes[:common.AddressLength])
w := common.BytesToAddress(wBytes)
dinkBytes := shared.GetDataBytesAtIndex(-2, ethLog.Data)
dink := big.NewInt(0).SetBytes(dinkBytes).String()
dartBytes := shared.GetDataBytesAtIndex(-1, ethLog.Data)

View File

@ -36,7 +36,7 @@ func (transformer VatTuneTransformer) Execute() error {
if err != nil {
return err
}
log.Printf("Fetching vat init event logs for %d headers \n", len(missingHeaders))
log.Printf("Fetching vat tune event logs for %d headers \n", len(missingHeaders))
for _, header := range missingHeaders {
topics := [][]common.Hash{{common.HexToHash(shared.VatTuneSignature)}}
matchingLogs, err := transformer.Fetcher.FetchLogs(VatTuneConfig.ContractAddresses, topics, header.BlockNumber)