Merge release/v1.20.0 into hyperspace

.circleci/config.yml

@@ -740,6 +740,11 @@ workflows:
  suite: itest-eth_filter
  target: "./itests/eth_filter_test.go"
 
+ - test:
+ name: test-itest-eth_hash_lookup
+ suite: itest-eth_hash_lookup
+ target: "./itests/eth_hash_lookup_test.go"
+
  - test:
  name: test-itest-eth_transactions
  suite: itest-eth_transactions

api/api_full.go

@@ -778,6 +778,7 @@ type FullNode interface {
  EthGetBlockByHash(ctx context.Context, blkHash ethtypes.EthHash, fullTxInfo bool) (ethtypes.EthBlock, error) //perm:read
  EthGetBlockByNumber(ctx context.Context, blkNum string, fullTxInfo bool) (ethtypes.EthBlock, error) //perm:read
  EthGetTransactionByHash(ctx context.Context, txHash *ethtypes.EthHash) (*ethtypes.EthTx, error) //perm:read
+ EthGetTransactionHashByCid(ctx context.Context, cid cid.Cid) (*ethtypes.EthHash, error) //perm:read
  EthGetTransactionCount(ctx context.Context, sender ethtypes.EthAddress, blkOpt string) (ethtypes.EthUint64, error) //perm:read
  EthGetTransactionReceipt(ctx context.Context, txHash ethtypes.EthHash) (*EthTxReceipt, error) //perm:read
  EthGetTransactionByBlockHashAndIndex(ctx context.Context, blkHash ethtypes.EthHash, txIndex ethtypes.EthUint64) (ethtypes.EthTx, error) //perm:read

build/params_wallaby.go

@@ -17,7 +17,7 @@ import (
 
 var NetworkBundle = "wallaby"
 var BundleOverrides map[actorstypes.Version]string
-var ActorDebugging = true
+var ActorDebugging = false
 
 const BootstrappersFile = "wallabynet.pi"
 const GenesisFile = "wallabynet.car"

chain/ethhashlookup/eth_transaction_hash_lookup.go

@@ -0,0 +1,163 @@
+package ethhashlookup
+
+import (
+ "database/sql"
+ "errors"
+ "strconv"
+
+ "github.com/ipfs/go-cid"
+ _ "github.com/mattn/go-sqlite3"
+ "golang.org/x/xerrors"
+
+ "github.com/filecoin-project/lotus/chain/types/ethtypes"
+)
+
+var ErrNotFound = errors.New("not found")
+
+var pragmas = []string{
+ "PRAGMA synchronous = normal",
+ "PRAGMA temp_store = memory",
+ "PRAGMA mmap_size = 30000000000",
+ "PRAGMA page_size = 32768",
+ "PRAGMA auto_vacuum = NONE",
+ "PRAGMA automatic_index = OFF",
+ "PRAGMA journal_mode = WAL",
+ "PRAGMA read_uncommitted = ON",
+}
+
+var ddls = []string{
+ `CREATE TABLE IF NOT EXISTS eth_tx_hashes (
+ hash TEXT PRIMARY KEY NOT NULL,
+ cid TEXT NOT NULL UNIQUE,
+ insertion_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP NOT NULL
+ )`,
+
+ `CREATE INDEX IF NOT EXISTS insertion_time_index ON eth_tx_hashes (insertion_time)`,
+
+ // metadata containing version of schema
+ `CREATE TABLE IF NOT EXISTS _meta (
+ version UINT64 NOT NULL UNIQUE
+ )`,
+
+ // version 1.
+ `INSERT OR IGNORE INTO _meta (version) VALUES (1)`,
+}
+
+const schemaVersion = 1
+
+const (
+ insertTxHash = `INSERT INTO eth_tx_hashes
+ (hash, cid)
+ VALUES(?, ?)
+ ON CONFLICT (hash) DO UPDATE SET insertion_time = CURRENT_TIMESTAMP`
+)
+
+type EthTxHashLookup struct {
+ db *sql.DB
+}
+
+func (ei *EthTxHashLookup) UpsertHash(txHash ethtypes.EthHash, c cid.Cid) error {
+ hashEntry, err := ei.db.Prepare(insertTxHash)
+ if err != nil {
+ return xerrors.Errorf("prepare insert event: %w", err)
+ }
+
+ _, err = hashEntry.Exec(txHash.String(), c.String())
+ return err
+}
+
+func (ei *EthTxHashLookup) GetCidFromHash(txHash ethtypes.EthHash) (cid.Cid, error) {
+ q, err := ei.db.Query("SELECT cid FROM eth_tx_hashes WHERE hash = :hash;", sql.Named("hash", txHash.String()))
+ if err != nil {
+ return cid.Undef, err
+ }
+
+ var c string
+ if !q.Next() {
+ return cid.Undef, ErrNotFound
+ }
+ err = q.Scan(&c)
+ if err != nil {
+ return cid.Undef, err
+ }
+ return cid.Decode(c)
+}
+
+func (ei *EthTxHashLookup) GetHashFromCid(c cid.Cid) (ethtypes.EthHash, error) {
+ q, err := ei.db.Query("SELECT hash FROM eth_tx_hashes WHERE cid = :cid;", sql.Named("cid", c.String()))
+ if err != nil {
+ return ethtypes.EmptyEthHash, err
+ }
+
+ var hashString string
+ if !q.Next() {
+ return ethtypes.EmptyEthHash, ErrNotFound
+ }
+ err = q.Scan(&hashString)
+ if err != nil {
+ return ethtypes.EmptyEthHash, err
+ }
+ return ethtypes.ParseEthHash(hashString)
+}
+
+func (ei *EthTxHashLookup) DeleteEntriesOlderThan(days int) (int64, error) {
+ res, err := ei.db.Exec("DELETE FROM eth_tx_hashes WHERE insertion_time < datetime('now', ?);", "-"+strconv.Itoa(days)+" day")
+ if err != nil {
+ return 0, err
+ }
+
+ return res.RowsAffected()
+}
+
+func NewTransactionHashLookup(path string) (*EthTxHashLookup, error) {
+ db, err := sql.Open("sqlite3", path+"?mode=rwc")
+ if err != nil {
+ return nil, xerrors.Errorf("open sqlite3 database: %w", err)
+ }
+
+ for _, pragma := range pragmas {
+ if _, err := db.Exec(pragma); err != nil {
+ _ = db.Close()
+ return nil, xerrors.Errorf("exec pragma %q: %w", pragma, err)
+ }
+ }
+
+ q, err := db.Query("SELECT name FROM sqlite_master WHERE type='table' AND name='_meta';")
+ if err == sql.ErrNoRows || !q.Next() {
+ // empty database, create the schema
+ for _, ddl := range ddls {
+ if _, err := db.Exec(ddl); err != nil {
+ _ = db.Close()
+ return nil, xerrors.Errorf("exec ddl %q: %w", ddl, err)
+ }
+ }
+ } else if err != nil {
+ _ = db.Close()
+ return nil, xerrors.Errorf("looking for _meta table: %w", err)
+ } else {
+ // Ensure we don't open a database from a different schema version
+
+ row := db.QueryRow("SELECT max(version) FROM _meta")
+ var version int
+ err := row.Scan(&version)
+ if err != nil {
+ _ = db.Close()
+ return nil, xerrors.Errorf("invalid database version: no version found")
+ }
+ if version != schemaVersion {
+ _ = db.Close()
+ return nil, xerrors.Errorf("invalid database version: got %d, expected %d", version, schemaVersion)
+ }
+ }
+
+ return &EthTxHashLookup{
+ db: db,
+ }, nil
+}
+
+func (ei *EthTxHashLookup) Close() error {
+ if ei.db == nil {
+ return nil
+ }
+ return ei.db.Close()
+}

chain/events/filter/mempool.go

@@ -5,7 +5,6 @@ import (
  "sync"
  "time"
 
- "github.com/ipfs/go-cid"
  "golang.org/x/xerrors"
 
  "github.com/filecoin-project/lotus/api"
@@ -18,7 +17,7 @@ type MemPoolFilter struct {
  ch chan<- interface{}
 
  mu sync.Mutex
- collected []cid.Cid
+ collected []*types.SignedMessage
  lastTaken time.Time
 }
 
@@ -55,10 +54,10 @@ func (f *MemPoolFilter) CollectMessage(ctx context.Context, msg *types.SignedMes
  copy(f.collected, f.collected[1:])
  f.collected = f.collected[:len(f.collected)-1]
  }
- f.collected = append(f.collected, msg.Cid())
+ f.collected = append(f.collected, msg)
 }
 
-func (f *MemPoolFilter) TakeCollectedMessages(context.Context) []cid.Cid {
+func (f *MemPoolFilter) TakeCollectedMessages(context.Context) []*types.SignedMessage {
  f.mu.Lock()
  collected := f.collected
  f.collected = nil

chain/types/ethtypes/eth_transactions.go

@@ -231,6 +231,36 @@ func (tx *EthTxArgs) ToRlpUnsignedMsg() ([]byte, error) {
  return append([]byte{0x02}, encoded...), nil
 }
 
+func (tx *EthTx) ToEthTxArgs() EthTxArgs {
+ return EthTxArgs{
+ ChainID: int(tx.ChainID),
+ Nonce: int(tx.Nonce),
+ To: tx.To,
+ Value: big.Int(tx.Value),
+ MaxFeePerGas: big.Int(tx.MaxFeePerGas),
+ MaxPriorityFeePerGas: big.Int(tx.MaxPriorityFeePerGas),
+ GasLimit: int(tx.Gas),
+ Input: tx.Input,
+ V: big.Int(tx.V),
+ R: big.Int(tx.R),
+ S: big.Int(tx.S),
+ }
+}
+
+func (tx *EthTx) TxHash() (EthHash, error) {
+ ethTxArgs := tx.ToEthTxArgs()
+ return (&ethTxArgs).TxHash()
+}
+
+func (tx *EthTxArgs) TxHash() (EthHash, error) {
+ rlp, err := tx.ToRlpSignedMsg()
+ if err != nil {
+ return EmptyEthHash, err
+ }
+
+ return EthHashFromTxBytes(rlp), nil
+}
+
 func (tx *EthTxArgs) ToRlpSignedMsg() ([]byte, error) {
  packed1, err := tx.packTxFields()
  if err != nil {

chain/types/ethtypes/eth_types.go

@@ -392,10 +392,21 @@ func ParseEthHash(s string) (EthHash, error) {
  return h, nil
 }
 
+func EthHashFromTxBytes(b []byte) EthHash {
+ hasher := sha3.NewLegacyKeccak256()
+ hasher.Write(b)
+ hash := hasher.Sum(nil)
+
+ var ethHash EthHash
+ copy(ethHash[:], hash)
+ return ethHash
+}
+
 func (h EthHash) String() string {
  return "0x" + hex.EncodeToString(h[:])
 }
 
+// Should ONLY be used for blocks and Filecoin messages. Eth transactions expect a different hashing scheme.
 func (h EthHash) ToCid() cid.Cid {
  // err is always nil
  mh, _ := multihash.EncodeName(h[:], "blake2b-256")
@@ -556,7 +567,7 @@ type EthLog struct {
  // The index corresponds to the sequence of messages produced by ChainGetParentMessages
  TransactionIndex EthUint64 `json:"transactionIndex"`
 
- // TransactionHash is the cid of the message that produced the event log.
+ // TransactionHash is the hash of the RLP message that produced the event log.
  TransactionHash EthHash `json:"transactionHash"`
 
  // BlockHash is the hash of the tipset containing the message that produced the log.

documentation/en/api-v1-unstable-methods.md

@@ -88,6 +88,7 @@
  * [EthGetTransactionByBlockNumberAndIndex](#EthGetTransactionByBlockNumberAndIndex)
  * [EthGetTransactionByHash](#EthGetTransactionByHash)
  * [EthGetTransactionCount](#EthGetTransactionCount)
+ * [EthGetTransactionHashByCid](#EthGetTransactionHashByCid)
  * [EthGetTransactionReceipt](#EthGetTransactionReceipt)
  * [EthMaxPriorityFeePerGas](#EthMaxPriorityFeePerGas)
  * [EthNewBlockFilter](#EthNewBlockFilter)
@@ -2778,6 +2779,22 @@ Inputs:
 
 Response: `"0x5"`
 
+### EthGetTransactionHashByCid
+
+
+Perms: read
+
+Inputs:
+```json
+[
+ {
+ "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+ }
+]
+```
+
+Response: `"0x37690cfec6c1bf4c3b9288c7a5d783e98731e90b0a4c177c2a374c7a9427355e"`
+
 ### EthGetTransactionReceipt
 
 

documentation/en/default-lotus-config.toml

@@ -343,3 +343,19 @@
  #ActorEventDatabasePath = ""
 
 
+[Fevm]
+ # EnableEthHashToFilecoinCidMapping enables storing a mapping of eth transaction hashes to filecoin message Cids
+ # You will not be able to look up ethereum transactions by their hash if this is disabled.
+ #
+ # type: bool
+ # env var: LOTUS_FEVM_ENABLEETHHASHTOFILECOINCIDMAPPING
+ #EnableEthHashToFilecoinCidMapping = false
+
+ # EthTxHashMappingLifetimeDays the transaction hash lookup database will delete mappings that have been stored for more than x days
+ # Set to 0 to keep all mappings
+ #
+ # type: int
+ # env var: LOTUS_FEVM_ETHTXHASHMAPPINGLIFETIMEDAYS
+ #EthTxHashMappingLifetimeDays = 0
+
+

itests/eth_deploy_test.go

@@ -41,6 +41,7 @@ func TestDeployment(t *testing.T) {
  cfg.ActorEvent.EnableRealTimeFilterAPI = true
  return nil
  }),
+ kit.EthTxHashLookup(),
  )
  ens.InterconnectAll().BeginMining(blockTime)