Support non-standard RPC methods for indexing services

.docker/docker-entrypoint-initdb.d/init.txt

@@ -490,6 +490,63 @@ BEGIN
   RETURN result;
 END;
 $$ LANGUAGE plpgsql VOLATILE PARALLEL UNSAFE;
+DROP FUNCTION IF EXISTS eth_getTransactionReceiptsByBlockNumber(blockno) RESTRICT;
+
+CREATE FUNCTION eth_getTransactionReceiptsByBlockNumber(block_id blockno) RETURNS transaction_receipt AS $$
+DECLARE
+  result transaction_receipt;
+BEGIN
+  SELECT
+        b.id AS "blockNumber",
+        b.hash AS "blockHash",
+        t.index AS "transactionIndex",
+        t.hash AS "transactionHash",
+        t.from AS "from",
+        t.to AS "to",
+        t.gas_used AS "gasUsed",
+        0::u256 AS "cumulativeGasUsed", -- TODO: tally?
+        CASE WHEN t.to IS NULL OR t.to = '\\x0000000000000000000000000000000000000000' THEN t.output
+             ELSE NULL
+        END AS "contractAddress",
+        NULL AS "logs",                 -- TODO: fetch event.id[]
+        repeat('\\000', 256)::bytea AS "logsBloom",
+        CASE WHEN t.status THEN 1 ELSE 0 END AS "status"
+      FROM transaction t
+        LEFT JOIN block b ON t.block = b.id
+      WHERE b.id = block_id
+    INTO STRICT result;
+  RETURN result;
+END;
+$$ LANGUAGE plpgsql VOLATILE PARALLEL UNSAFE;
+DROP FUNCTION IF EXISTS eth_getTransactionsByBlockNumber(blockno) RESTRICT;
+
+CREATE FUNCTION eth_getTransactionsByBlockNumber(block_id blockno) RETURNS transaction_result AS $$
+DECLARE
+  result transaction_result;
+BEGIN
+  SELECT
+        b.id AS "blockNumber",
+        b.hash AS "blockHash",
+        t.index AS "transactionIndex",
+        t.hash AS "hash",
+        t.from AS "from",
+        t.to AS "to",
+        t.gas_limit AS "gas",
+        t.gas_price AS "gasPrice",
+        t.nonce AS "nonce",
+        t.value AS "value",
+        coalesce(t.input, '\\x'::bytea) AS "input",
+        t.v AS "v",
+        t.r AS "r",
+        t.s AS "s"
+      FROM transaction t
+      LEFT JOIN block b ON t.block = b.id
+      WHERE b.id = block_id
+    INTO STRICT result;
+  RETURN result;
+END;
+$$ LANGUAGE plpgsql VOLATILE PARALLEL UNSAFE;
+
 DROP FUNCTION IF EXISTS eth_getUncleByBlockHashAndIndex(hash, int) RESTRICT;
 
 CREATE FUNCTION eth_getUncleByBlockHashAndIndex(block_hash hash, uncle_index int) RETURNS block_result AS $$

etc/methods.yaml

@@ -211,7 +211,18 @@ eth_getTransactionByBlockNumberAndIndex:
   implementations:
     - etc/schema/functions/eth_getTransactionByBlockNumberAndIndex.sql
     - src/servers/skeleton.ts
-
+eth_getTransactionsByBlockNumber:
+  status: ok
+  comment:
+  link: 
+  implementations:
+    - src/servers/skeleton.ts
+eth_getTransactionReceiptsByBlockNumber:
+  status: ok
+  comment:
+  link: 
+  implementations:
+    - src/servers/skeleton.ts
 eth_getTransactionByHash:
   status: wip
   comment:

etc/schema.sql

@@ -28,3 +28,5 @@
 \i etc/schema/functions/eth_newFilter.sql
 \i etc/schema/functions/eth_newPendingTransactionFilter.sql
 \i etc/schema/functions/eth_uninstallFilter.sql
+\i etc/schema/functions/eth_getTransactionsByBlockNumber.sql
+\i etc/schema/functions/eth_getTransactionReceiptsByBlockNumber.sql

etc/schema/functions/eth_getTransactionReceiptsByBlockNumber.sql

@@ -0,0 +1,28 @@
+DROP FUNCTION IF EXISTS eth_getTransactionReceiptsByBlockNumber(blockno) RESTRICT;
+
+CREATE FUNCTION eth_getTransactionReceiptsByBlockNumber(block_id blockno) RETURNS transaction_receipt AS $$
+DECLARE
+  result transaction_receipt;
+BEGIN
+  SELECT
+        b.id AS "blockNumber",
+        b.hash AS "blockHash",
+        t.index AS "transactionIndex",
+        t.hash AS "transactionHash",
+        t.from AS "from",
+        t.to AS "to",
+        t.gas_used AS "gasUsed",
+        0::u256 AS "cumulativeGasUsed", -- TODO: tally?
+        CASE WHEN t.to IS NULL OR t.to = '\\x0000000000000000000000000000000000000000' THEN t.output
+             ELSE NULL
+        END AS "contractAddress",
+        NULL AS "logs",                 -- TODO: fetch event.id[]
+        repeat('\\000', 256)::bytea AS "logsBloom",
+        CASE WHEN t.status THEN 1 ELSE 0 END AS "status"
+      FROM transaction t
+        LEFT JOIN block b ON t.block = b.id
+      WHERE b.id = block_id
+    INTO STRICT result;
+  RETURN result;
+END;
+$$ LANGUAGE plpgsql VOLATILE PARALLEL UNSAFE;

etc/schema/functions/eth_getTransactionsByBlockNumber.sql

@@ -0,0 +1,28 @@
+DROP FUNCTION IF EXISTS eth_getTransactionsByBlockNumber(blockno) RESTRICT;
+
+CREATE FUNCTION eth_getTransactionsByBlockNumber(block_id blockno) RETURNS transaction_result AS $$
+DECLARE
+  result transaction_result;
+BEGIN
+  SELECT
+        b.id AS "blockNumber",
+        b.hash AS "blockHash",
+        t.index AS "transactionIndex",
+        t.hash AS "hash",
+        t.from AS "from",
+        t.to AS "to",
+        t.gas_limit AS "gas",
+        t.gas_price AS "gasPrice",
+        t.nonce AS "nonce",
+        t.value AS "value",
+        coalesce(t.input, '\\x'::bytea) AS "input",
+        t.v AS "v",
+        t.r AS "r",
+        t.s AS "s"
+      FROM transaction t
+      LEFT JOIN block b ON t.block = b.id
+      WHERE b.id = block_id
+    INTO STRICT result;
+  RETURN result;
+END;
+$$ LANGUAGE plpgsql VOLATILE PARALLEL UNSAFE;

lib/servers/database.d.ts

@@ -23,10 +23,12 @@ export declare class DatabaseServer extends SkeletonServer {
     eth_getLogs(_request: Request, filter: web3.FilterOptions): Promise<web3.LogObject[]>;
     eth_getStorageAt(_request: Request, address: web3.Data, key: web3.Quantity, blockNumber: web3.Quantity | web3.Tag): Promise<web3.Data>;
     eth_getTransactionByBlockHashAndIndex(_request: Request, blockHash: web3.Data, transactionIndex: web3.Quantity): Promise<web3.TransactionResult | null>;
+    eth_getTransactionsByBlockNumber(_request: any, blockNumber: web3.Quantity | web3.Tag): Promise<web3.TransactionResult | null>;
     eth_getTransactionByBlockNumberAndIndex(_request: Request, blockNumber: web3.Quantity | web3.Tag, transactionIndex: web3.Quantity): Promise<web3.TransactionResult | null>;
     eth_getTransactionByHash(_request: Request, transactionHash: web3.Data): Promise<web3.TransactionResult | null>;
     eth_getTransactionCount(_request: Request, address: web3.Data, blockNumber: web3.Quantity | web3.Tag): Promise<web3.Quantity>;
     eth_getTransactionReceipt(_request: Request, transactionHash: string): Promise<web3.TransactionReceipt | null>;
+    eth_getTransactionReceiptsByBlockNumber(_request: any, blockNumber: web3.Quantity | web3.Tag): Promise<web3.TransactionReceipt[] | null>;
     eth_getUncleCountByBlockHash(_request: Request, blockHash: web3.Data): Promise<web3.Quantity | null>;
     eth_getUncleCountByBlockNumber(_request: Request, blockNumber: web3.Quantity | web3.Tag): Promise<web3.Quantity | null>;
     eth_newBlockFilter(_request: Request): Promise<web3.Quantity>;

lib/servers/skeleton.d.ts

@@ -45,6 +45,8 @@ export declare abstract class SkeletonServer implements web3.Service {
     eth_getStorageAt(_request: Request, _address: web3.Data, _key: web3.Quantity, _blockNumber: web3.Quantity | web3.Tag): Promise<web3.Data>;
     eth_getTransactionByBlockHashAndIndex(_request: Request, _blockHash: web3.Data, _transactionIndex: web3.Quantity): Promise<web3.TransactionResult | null>;
     eth_getTransactionByBlockNumberAndIndex(_request: Request, _blockNumber: web3.Quantity | web3.Tag, _transactionIndex: web3.Quantity): Promise<web3.TransactionResult | null>;
+    eth_getTransactionsByBlockNumber(_request: any, _blockNumber: web3.Quantity | web3.Tag): Promise<web3.TransactionResult | null>;
+    eth_getTransactionReceiptsByBlockNumber(_request: any, _blockNumber: web3.Quantity | web3.Tag): Promise<web3.TransactionReceipt[] | null>;
     eth_getTransactionByHash(_request: Request, _transactionHash: web3.Data): Promise<web3.TransactionResult | null>;
     eth_getTransactionCount(_request: Request, _address: web3.Data, _blockNumber: web3.Quantity | web3.Tag): Promise<web3.Quantity>;
     eth_getTransactionReceipt(_request: Request, _transactionHash: string): Promise<web3.TransactionReceipt | null>;

lib/web3.d.ts

@@ -78,6 +78,8 @@ export interface Service {
     eth_getProof(_request: Request, address: Data, keys: Data[], blockNumber: Quantity | Tag): Promise<ProofResult>;
     eth_getStorageAt(_request: Request, address: Data, key: Quantity, blockNumber: Quantity | Tag): Promise<Data>;
     eth_getTransactionByBlockHashAndIndex(_request: Request, blockHash: Data, transactionIndex: Quantity): Promise<TransactionResult | null>;
+    eth_getTransactionsByBlockNumber(_request: any, blockNumber: Quantity | Tag): Promise<TransactionResult | null>;
+    eth_getTransactionReceiptsByBlockNumber(_request: any, blockNumber: Quantity | Tag): Promise<TransactionReceipt[] | null>;
     eth_getTransactionByBlockNumberAndIndex(_request: Request, blockNumber: Quantity | Tag, transactionIndex: Quantity): Promise<TransactionResult | null>;
     eth_getTransactionByHash(_request: Request, transactionHash: Data): Promise<TransactionResult | null>;
     eth_getTransactionCount(_request: Request, address: Data, blockNumber: Quantity | Tag): Promise<Quantity>;

src/servers/database.ts

@@ -470,7 +470,28 @@ export class DatabaseServer extends SkeletonServer {
       return null;
     }
   }
-
+  async eth_getTransactionsByBlockNumber(
+    _request: any,
+    blockNumber: web3.Quantity | web3.Tag
+  ): Promise<web3.TransactionResult | null> {
+    const blockNumber_ = parseBlockSpec(blockNumber) != 0
+            ? parseBlockSpec(blockNumber) || (await this._fetchCurrentBlockID())
+            : parseBlockSpec(blockNumber);
+
+    try {
+      const {
+        rows,
+      } = await this._query('SELECT * FROM eth_getTransactionsByBlockNumber($1)', [
+        blockNumber_,
+      ]);
+      return !rows || !rows.length ? null : exportJSON(rows);
+    } catch (error) {
+      if (this.config.debug) {
+        console.debug('eth_getTransactionsByBlockNumber', error);
+      }
+      return null;
+    }
+  }
   async eth_getTransactionByBlockNumberAndIndex(
     _request: Request,
     blockNumber: web3.Quantity | web3.Tag,
@@ -557,7 +578,31 @@ export class DatabaseServer extends SkeletonServer {
       return null;
     }
   }
-
+  async eth_getTransactionReceiptsByBlockNumber(
+    _request: any,
+    blockNumber: web3.Quantity | web3.Tag
+  ): Promise<web3.TransactionReceipt[] | null> {
+    const blockNumber_ = parseBlockSpec(blockNumber) != 0
+            ? parseBlockSpec(blockNumber) || (await this._fetchCurrentBlockID())
+            : parseBlockSpec(blockNumber);
+    try {
+      const {
+        rows
+      } = await this._query(
+        'SELECT * FROM eth_getTransactionReceiptsByBlockNumber($1)',
+        [blockNumber_]
+      );
+      for(let i = 0;i<rows.length;i++){
+        rows[i].logs = await this._fetchEvents(hexToBytes(rows[i].transactionHash.toString()));
+      }
+      return exportJSON(rows);
+    } catch (error) {
+      if (this.config.debug) {
+        console.debug('eth_getTransactionReceiptsByBlockNumber', error);
+      }
+      return null;
+    }
+  }
   async eth_getUncleCountByBlockHash(
     _request: Request,
     blockHash: web3.Data

src/servers/skeleton.ts

@@ -290,7 +290,20 @@ export abstract class SkeletonServer implements web3.Service {
     unimplemented('eth_getTransactionByBlockNumberAndIndex');
     return null;
   }
-
+  async eth_getTransactionsByBlockNumber(
+    _request: any,
+    _blockNumber: web3.Quantity | web3.Tag
+  ): Promise<web3.TransactionResult | null> {
+    unimplemented('eth_getTransactionsByBlockNumber');
+    return null;
+  }
+  async eth_getTransactionReceiptsByBlockNumber(
+    _request: any,
+    _blockNumber: web3.Quantity | web3.Tag
+  ): Promise<web3.TransactionReceipt[] | null> {
+    unimplemented('eth_getTransactionReceiptsByBlockNumber');
+    return null;
+  }
   async eth_getTransactionByHash(
     _request: Request,
     _transactionHash: web3.Data

src/web3.ts

@@ -148,6 +148,14 @@ export interface Service {
     blockHash: Data,
     transactionIndex: Quantity
   ): Promise<TransactionResult | null>;
+  eth_getTransactionsByBlockNumber(
+    _request: any,
+    blockNumber:  Quantity | Tag,
+  ): Promise<TransactionResult | null>;
+  eth_getTransactionReceiptsByBlockNumber(
+    _request: any,
+    blockNumber:  Quantity | Tag,
+  ): Promise<TransactionReceipt[] | null>;
   eth_getTransactionByBlockNumberAndIndex(
     _request: Request,
     blockNumber: Quantity | Tag,